/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- * vim: set ts=8 sts=4 et sw=4 tw=99: * * ***** BEGIN LICENSE BLOCK ***** * Copyright (C) 2008 Apple Inc. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * ***** END LICENSE BLOCK ***** */#ifndef jit_x86_shared_BaseAssembler_x86_shared_h#define jit_x86_shared_BaseAssembler_x86_shared_h#include"mozilla/IntegerPrintfMacros.h"#include"jit/x86-shared/AssemblerBuffer-x86-shared.h"#include"jit/x86-shared/Encoding-x86-shared.h"#include"jit/x86-shared/Patching-x86-shared.h"externvolatileuintptr_t*blackbox;namespacejs{namespacejit{namespaceX86Encoding{classBaseAssembler;classBaseAssembler:publicGenericAssembler{public:BaseAssembler():useVEX_(true){}voiddisableVEX(){useVEX_=false;}size_tsize()const{returnm_formatter.size();}constunsignedchar*buffer()const{returnm_formatter.buffer();}unsignedchar*data(){returnm_formatter.data();}booloom()const{returnm_formatter.oom();}voiddisableProtection(){m_formatter.disableProtection();}voidenableProtection(){m_formatter.enableProtection();}voidsetLowerBoundForProtection(size_tsize){m_formatter.setLowerBoundForProtection(size);}voidunprotectRegion(unsignedchar*first,size_tsize){m_formatter.unprotectRegion(first,size);}voidreprotectRegion(unsignedchar*first,size_tsize){m_formatter.reprotectRegion(first,size);}voidnop(){spew("nop");m_formatter.oneByteOp(OP_NOP);}voidcomment(constchar*msg){spew("; %s",msg);}MOZ_MUST_USEJmpSrctwoByteNop(){spew("nop (2 byte)");JmpSrcr(m_formatter.size());m_formatter.prefix(PRE_OPERAND_SIZE);m_formatter.oneByteOp(OP_NOP);returnr;}staticvoidpatchTwoByteNopToJump(uint8_t*jump,uint8_t*target){// Note: the offset is relative to the address of the instruction after// the jump which is two bytes.ptrdiff_trel8=target-jump-2;MOZ_RELEASE_ASSERT(rel8>=INT8_MIN&&rel8<=INT8_MAX);MOZ_RELEASE_ASSERT(jump[0]==PRE_OPERAND_SIZE);MOZ_RELEASE_ASSERT(jump[1]==OP_NOP);jump[0]=OP_JMP_rel8;jump[1]=rel8;}staticvoidpatchJumpToTwoByteNop(uint8_t*jump){// See twoByteNop.MOZ_RELEASE_ASSERT(jump[0]==OP_JMP_rel8);jump[0]=PRE_OPERAND_SIZE;jump[1]=OP_NOP;}staticvoidpatchFiveByteNopToCall(uint8_t*callsite,uint8_t*target){// Note: the offset is relative to the address of the instruction after// the call which is five bytes.uint8_t*inst=callsite-sizeof(int32_t)-1;// The nop can be already patched as call, overriding the call.// See also nop_five.MOZ_ASSERT(inst[0]==OP_NOP_0F||inst[0]==OP_CALL_rel32);MOZ_ASSERT_IF(inst[0]==OP_NOP_0F,inst[1]==OP_NOP_1F||inst[2]==OP_NOP_44||inst[3]==OP_NOP_00||inst[4]==OP_NOP_00);inst[0]=OP_CALL_rel32;SetRel32(callsite,target);}staticvoidpatchCallToFiveByteNop(uint8_t*callsite){// See also patchFiveByteNopToCall and nop_five.uint8_t*inst=callsite-sizeof(int32_t)-1;// The call can be already patched as nop.if(inst[0]==OP_NOP_0F){MOZ_ASSERT(inst[1]==OP_NOP_1F||inst[2]==OP_NOP_44||inst[3]==OP_NOP_00||inst[4]==OP_NOP_00);return;}MOZ_ASSERT(inst[0]==OP_CALL_rel32);inst[0]=OP_NOP_0F;inst[1]=OP_NOP_1F;inst[2]=OP_NOP_44;inst[3]=OP_NOP_00;inst[4]=OP_NOP_00;}/* * The nop multibytes sequences are directly taken from the Intel's * architecture software developer manual. * They are defined for sequences of sizes from 1 to 9 included. */voidnop_one(){m_formatter.oneByteOp(OP_NOP);}voidnop_two(){m_formatter.oneByteOp(OP_NOP_66);m_formatter.oneByteOp(OP_NOP);}voidnop_three(){m_formatter.oneByteOp(OP_NOP_0F);m_formatter.oneByteOp(OP_NOP_1F);m_formatter.oneByteOp(OP_NOP_00);}voidnop_four(){m_formatter.oneByteOp(OP_NOP_0F);m_formatter.oneByteOp(OP_NOP_1F);m_formatter.oneByteOp(OP_NOP_40);m_formatter.oneByteOp(OP_NOP_00);}voidnop_five(){m_formatter.oneByteOp(OP_NOP_0F);m_formatter.oneByteOp(OP_NOP_1F);m_formatter.oneByteOp(OP_NOP_44);m_formatter.oneByteOp(OP_NOP_00);m_formatter.oneByteOp(OP_NOP_00);}voidnop_six(){m_formatter.oneByteOp(OP_NOP_66);nop_five();}voidnop_seven(){m_formatter.oneByteOp(OP_NOP_0F);m_formatter.oneByteOp(OP_NOP_1F);m_formatter.oneByteOp(OP_NOP_80);for(inti=0;i<4;++i)m_formatter.oneByteOp(OP_NOP_00);}voidnop_eight(){m_formatter.oneByteOp(OP_NOP_0F);m_formatter.oneByteOp(OP_NOP_1F);m_formatter.oneByteOp(OP_NOP_84);for(inti=0;i<5;++i)m_formatter.oneByteOp(OP_NOP_00);}voidnop_nine(){m_formatter.oneByteOp(OP_NOP_66);nop_eight();}voidinsert_nop(intsize){switch(size){case1:nop_one();break;case2:nop_two();break;case3:nop_three();break;case4:nop_four();break;case5:nop_five();break;case6:nop_six();break;case7:nop_seven();break;case8:nop_eight();break;case9:nop_nine();break;case10:nop_three();nop_seven();break;case11:nop_four();nop_seven();break;case12:nop_six();nop_six();break;case13:nop_six();nop_seven();break;case14:nop_seven();nop_seven();break;case15:nop_one();nop_seven();nop_seven();break;default:MOZ_CRASH("Unhandled alignment");}}// Stack operations:voidpush_r(RegisterIDreg){spew("push %s",GPRegName(reg));m_formatter.oneByteOp(OP_PUSH_EAX,reg);}voidpop_r(RegisterIDreg){spew("pop %s",GPRegName(reg));m_formatter.oneByteOp(OP_POP_EAX,reg);}voidpush_i(int32_timm){spew("push $%s0x%x",PRETTYHEX(imm));if(CAN_SIGN_EXTEND_8_32(imm)){m_formatter.oneByteOp(OP_PUSH_Ib);m_formatter.immediate8s(imm);}else{m_formatter.oneByteOp(OP_PUSH_Iz);m_formatter.immediate32(imm);}}voidpush_i32(int32_timm){spew("push $%s0x%04x",PRETTYHEX(imm));m_formatter.oneByteOp(OP_PUSH_Iz);m_formatter.immediate32(imm);}voidpush_m(int32_toffset,RegisterIDbase){spew("push "MEM_ob,ADDR_ob(offset,base));m_formatter.oneByteOp(OP_GROUP5_Ev,offset,base,GROUP5_OP_PUSH);}voidpop_m(int32_toffset,RegisterIDbase){spew("pop "MEM_ob,ADDR_ob(offset,base));m_formatter.oneByteOp(OP_GROUP1A_Ev,offset,base,GROUP1A_OP_POP);}voidpush_flags(){spew("pushf");m_formatter.oneByteOp(OP_PUSHFLAGS);}voidpop_flags(){spew("popf");m_formatter.oneByteOp(OP_POPFLAGS);}// Arithmetic operations:voidaddl_rr(RegisterIDsrc,RegisterIDdst){spew("addl %s, %s",GPReg32Name(src),GPReg32Name(dst));m_formatter.oneByteOp(OP_ADD_GvEv,src,dst);}voidaddw_rr(RegisterIDsrc,RegisterIDdst){spew("addw %s, %s",GPReg16Name(src),GPReg16Name(dst));m_formatter.prefix(PRE_OPERAND_SIZE);m_formatter.oneByteOp(OP_ADD_GvEv,src,dst);}voidaddl_mr(int32_toffset,RegisterIDbase,RegisterIDdst){spew("addl "MEM_ob", %s",ADDR_ob(offset,base),GPReg32Name(dst));m_formatter.oneByteOp(OP_ADD_GvEv,offset,base,dst);}voidaddl_rm(RegisterIDsrc,int32_toffset,RegisterIDbase){spew("addl %s, "MEM_ob,GPReg32Name(src),ADDR_ob(offset,base));m_formatter.oneByteOp(OP_ADD_EvGv,offset,base,src);}voidaddl_rm(RegisterIDsrc,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("addl %s, "MEM_obs,GPReg32Name(src),ADDR_obs(offset,base,index,scale));m_formatter.oneByteOp(OP_ADD_EvGv,offset,base,index,scale,src);}voidaddl_ir(int32_timm,RegisterIDdst){spew("addl $%d, %s",imm,GPReg32Name(dst));if(CAN_SIGN_EXTEND_8_32(imm)){m_formatter.oneByteOp(OP_GROUP1_EvIb,dst,GROUP1_OP_ADD);m_formatter.immediate8s(imm);}else{if(dst==rax)m_formatter.oneByteOp(OP_ADD_EAXIv);elsem_formatter.oneByteOp(OP_GROUP1_EvIz,dst,GROUP1_OP_ADD);m_formatter.immediate32(imm);}}voidaddw_ir(int32_timm,RegisterIDdst){spew("addw $%d, %s",int16_t(imm),GPReg16Name(dst));m_formatter.prefix(PRE_OPERAND_SIZE);m_formatter.oneByteOp(OP_GROUP1_EvIz,dst,GROUP1_OP_ADD);m_formatter.immediate16(imm);}voidaddl_i32r(int32_timm,RegisterIDdst){// 32-bit immediate always, for patching.spew("addl $0x%04x, %s",imm,GPReg32Name(dst));if(dst==rax)m_formatter.oneByteOp(OP_ADD_EAXIv);elsem_formatter.oneByteOp(OP_GROUP1_EvIz,dst,GROUP1_OP_ADD);m_formatter.immediate32(imm);}voidaddl_im(int32_timm,int32_toffset,RegisterIDbase){spew("addl $%d, "MEM_ob,imm,ADDR_ob(offset,base));if(CAN_SIGN_EXTEND_8_32(imm)){m_formatter.oneByteOp(OP_GROUP1_EvIb,offset,base,GROUP1_OP_ADD);m_formatter.immediate8s(imm);}else{m_formatter.oneByteOp(OP_GROUP1_EvIz,offset,base,GROUP1_OP_ADD);m_formatter.immediate32(imm);}}voidaddl_im(int32_timm,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("addl $%d, "MEM_obs,imm,ADDR_obs(offset,base,index,scale));if(CAN_SIGN_EXTEND_8_32(imm)){m_formatter.oneByteOp(OP_GROUP1_EvIb,offset,base,index,scale,GROUP1_OP_ADD);m_formatter.immediate8s(imm);}else{m_formatter.oneByteOp(OP_GROUP1_EvIz,offset,base,index,scale,GROUP1_OP_ADD);m_formatter.immediate32(imm);}}voidaddl_im(int32_timm,constvoid*addr){spew("addl $%d, %p",imm,addr);if(CAN_SIGN_EXTEND_8_32(imm)){m_formatter.oneByteOp(OP_GROUP1_EvIb,addr,GROUP1_OP_ADD);m_formatter.immediate8s(imm);}else{m_formatter.oneByteOp(OP_GROUP1_EvIz,addr,GROUP1_OP_ADD);m_formatter.immediate32(imm);}}voidaddw_im(int32_timm,constvoid*addr){spew("addw $%d, %p",int16_t(imm),addr);m_formatter.prefix(PRE_OPERAND_SIZE);if(CAN_SIGN_EXTEND_8_32(imm)){m_formatter.oneByteOp(OP_GROUP1_EvIb,addr,GROUP1_OP_ADD);m_formatter.immediate8s(imm);}else{m_formatter.oneByteOp(OP_GROUP1_EvIz,addr,GROUP1_OP_ADD);m_formatter.immediate16(imm);}}voidaddw_im(int32_timm,int32_toffset,RegisterIDbase){spew("addw $%d, "MEM_ob,int16_t(imm),ADDR_ob(offset,base));m_formatter.prefix(PRE_OPERAND_SIZE);m_formatter.oneByteOp(OP_GROUP1_EvIz,offset,base,GROUP1_OP_ADD);m_formatter.immediate16(imm);}voidaddw_im(int32_timm,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("addw $%d, "MEM_obs,int16_t(imm),ADDR_obs(offset,base,index,scale));m_formatter.prefix(PRE_OPERAND_SIZE);m_formatter.oneByteOp(OP_GROUP1_EvIz,offset,base,index,scale,GROUP1_OP_ADD);m_formatter.immediate16(imm);}voidaddw_rm(RegisterIDsrc,int32_toffset,RegisterIDbase){spew("addw %s, "MEM_ob,GPReg16Name(src),ADDR_ob(offset,base));m_formatter.prefix(PRE_OPERAND_SIZE);m_formatter.oneByteOp(OP_ADD_EvGv,offset,base,src);}voidaddw_rm(RegisterIDsrc,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("addw %s, "MEM_obs,GPReg16Name(src),ADDR_obs(offset,base,index,scale));m_formatter.prefix(PRE_OPERAND_SIZE);m_formatter.oneByteOp(OP_ADD_EvGv,offset,base,index,scale,src);}voidaddb_im(int32_timm,int32_toffset,RegisterIDbase){spew("addb $%d, "MEM_ob,int8_t(imm),ADDR_ob(offset,base));m_formatter.oneByteOp(OP_GROUP1_EbIb,offset,base,GROUP1_OP_ADD);m_formatter.immediate8(imm);}voidaddb_im(int32_timm,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("addb $%d, "MEM_obs,int8_t(imm),ADDR_obs(offset,base,index,scale));m_formatter.oneByteOp(OP_GROUP1_EbIb,offset,base,index,scale,GROUP1_OP_ADD);m_formatter.immediate8(imm);}voidaddb_rm(RegisterIDsrc,int32_toffset,RegisterIDbase){spew("addb %s, "MEM_ob,GPReg8Name(src),ADDR_ob(offset,base));m_formatter.oneByteOp8(OP_ADD_EbGb,offset,base,src);}voidaddb_rm(RegisterIDsrc,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("addb %s, "MEM_obs,GPReg8Name(src),ADDR_obs(offset,base,index,scale));m_formatter.oneByteOp8(OP_ADD_EbGb,offset,base,index,scale,src);}voidsubb_im(int32_timm,int32_toffset,RegisterIDbase){spew("subb $%d, "MEM_ob,int8_t(imm),ADDR_ob(offset,base));m_formatter.oneByteOp(OP_GROUP1_EbIb,offset,base,GROUP1_OP_SUB);m_formatter.immediate8(imm);}voidsubb_im(int32_timm,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("subb $%d, "MEM_obs,int8_t(imm),ADDR_obs(offset,base,index,scale));m_formatter.oneByteOp(OP_GROUP1_EbIb,offset,base,index,scale,GROUP1_OP_SUB);m_formatter.immediate8(imm);}voidsubb_rm(RegisterIDsrc,int32_toffset,RegisterIDbase){spew("subb %s, "MEM_ob,GPReg8Name(src),ADDR_ob(offset,base));m_formatter.oneByteOp8(OP_SUB_EbGb,offset,base,src);}voidsubb_rm(RegisterIDsrc,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("subb %s, "MEM_obs,GPReg8Name(src),ADDR_obs(offset,base,index,scale));m_formatter.oneByteOp8(OP_SUB_EbGb,offset,base,index,scale,src);}voidandb_im(int32_timm,int32_toffset,RegisterIDbase){spew("andb $%d, "MEM_ob,int8_t(imm),ADDR_ob(offset,base));m_formatter.oneByteOp(OP_GROUP1_EbIb,offset,base,GROUP1_OP_AND);m_formatter.immediate8(imm);}voidandb_im(int32_timm,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("andb $%d, "MEM_obs,int8_t(imm),ADDR_obs(offset,base,index,scale));m_formatter.oneByteOp(OP_GROUP1_EbIb,offset,base,index,scale,GROUP1_OP_AND);m_formatter.immediate8(imm);}voidandb_rm(RegisterIDsrc,int32_toffset,RegisterIDbase){spew("andb %s, "MEM_ob,GPReg8Name(src),ADDR_ob(offset,base));m_formatter.oneByteOp8(OP_AND_EbGb,offset,base,src);}voidandb_rm(RegisterIDsrc,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("andb %s, "MEM_obs,GPReg8Name(src),ADDR_obs(offset,base,index,scale));m_formatter.oneByteOp8(OP_AND_EbGb,offset,base,index,scale,src);}voidorb_im(int32_timm,int32_toffset,RegisterIDbase){spew("orb $%d, "MEM_ob,int8_t(imm),ADDR_ob(offset,base));m_formatter.oneByteOp(OP_GROUP1_EbIb,offset,base,GROUP1_OP_OR);m_formatter.immediate8(imm);}voidorb_im(int32_timm,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("orb $%d, "MEM_obs,int8_t(imm),ADDR_obs(offset,base,index,scale));m_formatter.oneByteOp(OP_GROUP1_EbIb,offset,base,index,scale,GROUP1_OP_OR);m_formatter.immediate8(imm);}voidorb_rm(RegisterIDsrc,int32_toffset,RegisterIDbase){spew("orb %s, "MEM_ob,GPReg8Name(src),ADDR_ob(offset,base));m_formatter.oneByteOp8(OP_OR_EbGb,offset,base,src);}voidorb_rm(RegisterIDsrc,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("orb %s, "MEM_obs,GPReg8Name(src),ADDR_obs(offset,base,index,scale));m_formatter.oneByteOp8(OP_OR_EbGb,offset,base,index,scale,src);}voidxorb_im(int32_timm,int32_toffset,RegisterIDbase){spew("xorb $%d, "MEM_ob,int8_t(imm),ADDR_ob(offset,base));m_formatter.oneByteOp(OP_GROUP1_EbIb,offset,base,GROUP1_OP_XOR);m_formatter.immediate8(imm);}voidxorb_im(int32_timm,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("xorb $%d, "MEM_obs,int8_t(imm),ADDR_obs(offset,base,index,scale));m_formatter.oneByteOp(OP_GROUP1_EbIb,offset,base,index,scale,GROUP1_OP_XOR);m_formatter.immediate8(imm);}voidxorb_rm(RegisterIDsrc,int32_toffset,RegisterIDbase){spew("xorb %s, "MEM_ob,GPReg8Name(src),ADDR_ob(offset,base));m_formatter.oneByteOp8(OP_XOR_EbGb,offset,base,src);}voidxorb_rm(RegisterIDsrc,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("xorb %s, "MEM_obs,GPReg8Name(src),ADDR_obs(offset,base,index,scale));m_formatter.oneByteOp8(OP_XOR_EbGb,offset,base,index,scale,src);}voidlock_xaddb_rm(RegisterIDsrcdest,int32_toffset,RegisterIDbase){spew("lock xaddb %s, "MEM_ob,GPReg8Name(srcdest),ADDR_ob(offset,base));m_formatter.oneByteOp(PRE_LOCK);m_formatter.twoByteOp8(OP2_XADD_EbGb,offset,base,srcdest);}voidlock_xaddb_rm(RegisterIDsrcdest,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("lock xaddb %s, "MEM_obs,GPReg8Name(srcdest),ADDR_obs(offset,base,index,scale));m_formatter.oneByteOp(PRE_LOCK);m_formatter.twoByteOp8(OP2_XADD_EbGb,offset,base,index,scale,srcdest);}voidlock_xaddl_rm(RegisterIDsrcdest,int32_toffset,RegisterIDbase){spew("lock xaddl %s, "MEM_ob,GPReg32Name(srcdest),ADDR_ob(offset,base));m_formatter.oneByteOp(PRE_LOCK);m_formatter.twoByteOp(OP2_XADD_EvGv,offset,base,srcdest);}voidlock_xaddl_rm(RegisterIDsrcdest,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("lock xaddl %s, "MEM_obs,GPReg32Name(srcdest),ADDR_obs(offset,base,index,scale));m_formatter.oneByteOp(PRE_LOCK);m_formatter.twoByteOp(OP2_XADD_EvGv,offset,base,index,scale,srcdest);}voidvpaddb_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpaddb",VEX_PD,OP2_PADDB_VdqWdq,src1,src0,dst);}voidvpaddb_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpaddb",VEX_PD,OP2_PADDB_VdqWdq,offset,base,src0,dst);}voidvpaddb_mr(constvoid*address,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpaddb",VEX_PD,OP2_PADDB_VdqWdq,address,src0,dst);}voidvpaddsb_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpaddsb",VEX_PD,OP2_PADDSB_VdqWdq,src1,src0,dst);}voidvpaddsb_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpaddsb",VEX_PD,OP2_PADDSB_VdqWdq,offset,base,src0,dst);}voidvpaddsb_mr(constvoid*address,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpaddsb",VEX_PD,OP2_PADDSB_VdqWdq,address,src0,dst);}voidvpaddusb_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpaddusb",VEX_PD,OP2_PADDUSB_VdqWdq,src1,src0,dst);}voidvpaddusb_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpaddusb",VEX_PD,OP2_PADDUSB_VdqWdq,offset,base,src0,dst);}voidvpaddusb_mr(constvoid*address,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpaddusb",VEX_PD,OP2_PADDUSB_VdqWdq,address,src0,dst);}voidvpaddw_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpaddw",VEX_PD,OP2_PADDW_VdqWdq,src1,src0,dst);}voidvpaddw_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpaddw",VEX_PD,OP2_PADDW_VdqWdq,offset,base,src0,dst);}voidvpaddw_mr(constvoid*address,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpaddw",VEX_PD,OP2_PADDW_VdqWdq,address,src0,dst);}voidvpaddsw_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpaddsw",VEX_PD,OP2_PADDSW_VdqWdq,src1,src0,dst);}voidvpaddsw_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpaddsw",VEX_PD,OP2_PADDSW_VdqWdq,offset,base,src0,dst);}voidvpaddsw_mr(constvoid*address,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpaddsw",VEX_PD,OP2_PADDSW_VdqWdq,address,src0,dst);}voidvpaddusw_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpaddusw",VEX_PD,OP2_PADDUSW_VdqWdq,src1,src0,dst);}voidvpaddusw_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpaddusw",VEX_PD,OP2_PADDUSW_VdqWdq,offset,base,src0,dst);}voidvpaddusw_mr(constvoid*address,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpaddusw",VEX_PD,OP2_PADDUSW_VdqWdq,address,src0,dst);}voidvpaddd_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpaddd",VEX_PD,OP2_PADDD_VdqWdq,src1,src0,dst);}voidvpaddd_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpaddd",VEX_PD,OP2_PADDD_VdqWdq,offset,base,src0,dst);}voidvpaddd_mr(constvoid*address,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpaddd",VEX_PD,OP2_PADDD_VdqWdq,address,src0,dst);}voidvpsubb_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpsubb",VEX_PD,OP2_PSUBB_VdqWdq,src1,src0,dst);}voidvpsubb_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpsubb",VEX_PD,OP2_PSUBB_VdqWdq,offset,base,src0,dst);}voidvpsubb_mr(constvoid*address,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpsubb",VEX_PD,OP2_PSUBB_VdqWdq,address,src0,dst);}voidvpsubsb_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpsubsb",VEX_PD,OP2_PSUBSB_VdqWdq,src1,src0,dst);}voidvpsubsb_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpsubsb",VEX_PD,OP2_PSUBSB_VdqWdq,offset,base,src0,dst);}voidvpsubsb_mr(constvoid*subress,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpsubsb",VEX_PD,OP2_PSUBSB_VdqWdq,subress,src0,dst);}voidvpsubusb_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpsubusb",VEX_PD,OP2_PSUBUSB_VdqWdq,src1,src0,dst);}voidvpsubusb_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpsubusb",VEX_PD,OP2_PSUBUSB_VdqWdq,offset,base,src0,dst);}voidvpsubusb_mr(constvoid*subress,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpsubusb",VEX_PD,OP2_PSUBUSB_VdqWdq,subress,src0,dst);}voidvpsubw_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpsubw",VEX_PD,OP2_PSUBW_VdqWdq,src1,src0,dst);}voidvpsubw_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpsubw",VEX_PD,OP2_PSUBW_VdqWdq,offset,base,src0,dst);}voidvpsubw_mr(constvoid*address,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpsubw",VEX_PD,OP2_PSUBW_VdqWdq,address,src0,dst);}voidvpsubsw_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpsubsw",VEX_PD,OP2_PSUBSW_VdqWdq,src1,src0,dst);}voidvpsubsw_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpsubsw",VEX_PD,OP2_PSUBSW_VdqWdq,offset,base,src0,dst);}voidvpsubsw_mr(constvoid*subress,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpsubsw",VEX_PD,OP2_PSUBSW_VdqWdq,subress,src0,dst);}voidvpsubusw_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpsubusw",VEX_PD,OP2_PSUBUSW_VdqWdq,src1,src0,dst);}voidvpsubusw_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpsubusw",VEX_PD,OP2_PSUBUSW_VdqWdq,offset,base,src0,dst);}voidvpsubusw_mr(constvoid*subress,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpsubusw",VEX_PD,OP2_PSUBUSW_VdqWdq,subress,src0,dst);}voidvpsubd_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpsubd",VEX_PD,OP2_PSUBD_VdqWdq,src1,src0,dst);}voidvpsubd_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpsubd",VEX_PD,OP2_PSUBD_VdqWdq,offset,base,src0,dst);}voidvpsubd_mr(constvoid*address,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpsubd",VEX_PD,OP2_PSUBD_VdqWdq,address,src0,dst);}voidvpmuludq_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpmuludq",VEX_PD,OP2_PMULUDQ_VdqWdq,src1,src0,dst);}voidvpmuludq_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpmuludq",VEX_PD,OP2_PMULUDQ_VdqWdq,offset,base,src0,dst);}voidvpmullw_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpmullw",VEX_PD,OP2_PMULLW_VdqWdq,src1,src0,dst);}voidvpmullw_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpmullw",VEX_PD,OP2_PMULLW_VdqWdq,offset,base,src0,dst);}voidvpmulld_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){threeByteOpSimd("vpmulld",VEX_PD,OP3_PMULLD_VdqWdq,ESCAPE_38,src1,src0,dst);}voidvpmulld_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){threeByteOpSimd("vpmulld",VEX_PD,OP3_PMULLD_VdqWdq,ESCAPE_38,offset,base,src0,dst);}voidvpmulld_mr(constvoid*address,XMMRegisterIDsrc0,XMMRegisterIDdst){threeByteOpSimd("vpmulld",VEX_PD,OP3_PMULLD_VdqWdq,ESCAPE_38,address,src0,dst);}voidvaddps_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vaddps",VEX_PS,OP2_ADDPS_VpsWps,src1,src0,dst);}voidvaddps_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vaddps",VEX_PS,OP2_ADDPS_VpsWps,offset,base,src0,dst);}voidvaddps_mr(constvoid*address,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vaddps",VEX_PS,OP2_ADDPS_VpsWps,address,src0,dst);}voidvsubps_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vsubps",VEX_PS,OP2_SUBPS_VpsWps,src1,src0,dst);}voidvsubps_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vsubps",VEX_PS,OP2_SUBPS_VpsWps,offset,base,src0,dst);}voidvsubps_mr(constvoid*address,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vsubps",VEX_PS,OP2_SUBPS_VpsWps,address,src0,dst);}voidvmulps_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vmulps",VEX_PS,OP2_MULPS_VpsWps,src1,src0,dst);}voidvmulps_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vmulps",VEX_PS,OP2_MULPS_VpsWps,offset,base,src0,dst);}voidvmulps_mr(constvoid*address,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vmulps",VEX_PS,OP2_MULPS_VpsWps,address,src0,dst);}voidvdivps_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vdivps",VEX_PS,OP2_DIVPS_VpsWps,src1,src0,dst);}voidvdivps_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vdivps",VEX_PS,OP2_DIVPS_VpsWps,offset,base,src0,dst);}voidvdivps_mr(constvoid*address,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vdivps",VEX_PS,OP2_DIVPS_VpsWps,address,src0,dst);}voidvmaxps_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vmaxps",VEX_PS,OP2_MAXPS_VpsWps,src1,src0,dst);}voidvmaxps_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vmaxps",VEX_PS,OP2_MAXPS_VpsWps,offset,base,src0,dst);}voidvmaxps_mr(constvoid*address,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vmaxps",VEX_PS,OP2_MAXPS_VpsWps,address,src0,dst);}voidvminps_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vminps",VEX_PS,OP2_MINPS_VpsWps,src1,src0,dst);}voidvminps_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vminps",VEX_PS,OP2_MINPS_VpsWps,offset,base,src0,dst);}voidvminps_mr(constvoid*address,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vminps",VEX_PS,OP2_MINPS_VpsWps,address,src0,dst);}voidandl_rr(RegisterIDsrc,RegisterIDdst){spew("andl %s, %s",GPReg32Name(src),GPReg32Name(dst));m_formatter.oneByteOp(OP_AND_GvEv,src,dst);}voidandw_rr(RegisterIDsrc,RegisterIDdst){spew("andw %s, %s",GPReg16Name(src),GPReg16Name(dst));m_formatter.prefix(PRE_OPERAND_SIZE);m_formatter.oneByteOp(OP_AND_GvEv,src,dst);}voidandl_mr(int32_toffset,RegisterIDbase,RegisterIDdst){spew("andl "MEM_ob", %s",ADDR_ob(offset,base),GPReg32Name(dst));m_formatter.oneByteOp(OP_AND_GvEv,offset,base,dst);}voidandl_rm(RegisterIDsrc,int32_toffset,RegisterIDbase){spew("andl %s, "MEM_ob,GPReg32Name(src),ADDR_ob(offset,base));m_formatter.oneByteOp(OP_AND_EvGv,offset,base,src);}voidandw_rm(RegisterIDsrc,int32_toffset,RegisterIDbase){spew("andw %s, "MEM_ob,GPReg16Name(src),ADDR_ob(offset,base));m_formatter.prefix(PRE_OPERAND_SIZE);m_formatter.oneByteOp(OP_AND_EvGv,offset,base,src);}voidandl_rm(RegisterIDsrc,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("andl %s, "MEM_obs,GPReg32Name(src),ADDR_obs(offset,base,index,scale));m_formatter.oneByteOp(OP_AND_EvGv,offset,base,index,scale,src);}voidandw_rm(RegisterIDsrc,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("andw %s, "MEM_obs,GPReg16Name(src),ADDR_obs(offset,base,index,scale));m_formatter.prefix(PRE_OPERAND_SIZE);m_formatter.oneByteOp(OP_AND_EvGv,offset,base,index,scale,src);}voidandl_ir(int32_timm,RegisterIDdst){spew("andl $0x%x, %s",imm,GPReg32Name(dst));if(CAN_SIGN_EXTEND_8_32(imm)){m_formatter.oneByteOp(OP_GROUP1_EvIb,dst,GROUP1_OP_AND);m_formatter.immediate8s(imm);}else{if(dst==rax)m_formatter.oneByteOp(OP_AND_EAXIv);elsem_formatter.oneByteOp(OP_GROUP1_EvIz,dst,GROUP1_OP_AND);m_formatter.immediate32(imm);}}voidandw_ir(int32_timm,RegisterIDdst){spew("andw $0x%x, %s",int16_t(imm),GPReg16Name(dst));m_formatter.prefix(PRE_OPERAND_SIZE);if(CAN_SIGN_EXTEND_8_32(imm)){m_formatter.oneByteOp(OP_GROUP1_EvIb,dst,GROUP1_OP_AND);m_formatter.immediate8s(imm);}else{if(dst==rax)m_formatter.oneByteOp(OP_AND_EAXIv);elsem_formatter.oneByteOp(OP_GROUP1_EvIz,dst,GROUP1_OP_AND);m_formatter.immediate16(imm);}}voidandl_im(int32_timm,int32_toffset,RegisterIDbase){spew("andl $0x%x, "MEM_ob,imm,ADDR_ob(offset,base));if(CAN_SIGN_EXTEND_8_32(imm)){m_formatter.oneByteOp(OP_GROUP1_EvIb,offset,base,GROUP1_OP_AND);m_formatter.immediate8s(imm);}else{m_formatter.oneByteOp(OP_GROUP1_EvIz,offset,base,GROUP1_OP_AND);m_formatter.immediate32(imm);}}voidandw_im(int32_timm,int32_toffset,RegisterIDbase){spew("andw $0x%x, "MEM_ob,int16_t(imm),ADDR_ob(offset,base));m_formatter.prefix(PRE_OPERAND_SIZE);if(CAN_SIGN_EXTEND_8_32(imm)){m_formatter.oneByteOp(OP_GROUP1_EvIb,offset,base,GROUP1_OP_AND);m_formatter.immediate8s(imm);}else{m_formatter.oneByteOp(OP_GROUP1_EvIz,offset,base,GROUP1_OP_AND);m_formatter.immediate16(imm);}}voidandl_im(int32_timm,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("andl $%d, "MEM_obs,imm,ADDR_obs(offset,base,index,scale));if(CAN_SIGN_EXTEND_8_32(imm)){m_formatter.oneByteOp(OP_GROUP1_EvIb,offset,base,index,scale,GROUP1_OP_AND);m_formatter.immediate8s(imm);}else{m_formatter.oneByteOp(OP_GROUP1_EvIz,offset,base,index,scale,GROUP1_OP_AND);m_formatter.immediate32(imm);}}voidandw_im(int32_timm,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("andw $%d, "MEM_obs,int16_t(imm),ADDR_obs(offset,base,index,scale));m_formatter.prefix(PRE_OPERAND_SIZE);if(CAN_SIGN_EXTEND_8_32(imm)){m_formatter.oneByteOp(OP_GROUP1_EvIb,offset,base,index,scale,GROUP1_OP_AND);m_formatter.immediate8s(imm);}else{m_formatter.oneByteOp(OP_GROUP1_EvIz,offset,base,index,scale,GROUP1_OP_AND);m_formatter.immediate16(imm);}}voidfld_m(int32_toffset,RegisterIDbase){spew("fld "MEM_ob,ADDR_ob(offset,base));m_formatter.oneByteOp(OP_FPU6,offset,base,FPU6_OP_FLD);}voidfld32_m(int32_toffset,RegisterIDbase){spew("fld "MEM_ob,ADDR_ob(offset,base));m_formatter.oneByteOp(OP_FPU6_F32,offset,base,FPU6_OP_FLD);}voidfaddp(){spew("addp ");m_formatter.oneByteOp(OP_FPU6_ADDP);m_formatter.oneByteOp(OP_ADDP_ST0_ST1);}voidfisttp_m(int32_toffset,RegisterIDbase){spew("fisttp "MEM_ob,ADDR_ob(offset,base));m_formatter.oneByteOp(OP_FPU6,offset,base,FPU6_OP_FISTTP);}voidfistp_m(int32_toffset,RegisterIDbase){spew("fistp "MEM_ob,ADDR_ob(offset,base));m_formatter.oneByteOp(OP_FILD,offset,base,FPU6_OP_FISTP);}voidfstp_m(int32_toffset,RegisterIDbase){spew("fstp "MEM_ob,ADDR_ob(offset,base));m_formatter.oneByteOp(OP_FPU6,offset,base,FPU6_OP_FSTP);}voidfstp32_m(int32_toffset,RegisterIDbase){spew("fstp32 "MEM_ob,ADDR_ob(offset,base));m_formatter.oneByteOp(OP_FPU6_F32,offset,base,FPU6_OP_FSTP);}voidfnstcw_m(int32_toffset,RegisterIDbase){spew("fnstcw "MEM_ob,ADDR_ob(offset,base));m_formatter.oneByteOp(OP_FPU6_F32,offset,base,FPU6_OP_FISTP);}voidfldcw_m(int32_toffset,RegisterIDbase){spew("fldcw "MEM_ob,ADDR_ob(offset,base));m_formatter.oneByteOp(OP_FPU6_F32,offset,base,FPU6_OP_FLDCW);}voidfnstsw_m(int32_toffset,RegisterIDbase){spew("fnstsw "MEM_ob,ADDR_ob(offset,base));m_formatter.oneByteOp(OP_FPU6,offset,base,FPU6_OP_FISTP);}voidnegl_r(RegisterIDdst){spew("negl %s",GPReg32Name(dst));m_formatter.oneByteOp(OP_GROUP3_Ev,dst,GROUP3_OP_NEG);}voidnegl_m(int32_toffset,RegisterIDbase){spew("negl "MEM_ob,ADDR_ob(offset,base));m_formatter.oneByteOp(OP_GROUP3_Ev,offset,base,GROUP3_OP_NEG);}voidnotl_r(RegisterIDdst){spew("notl %s",GPReg32Name(dst));m_formatter.oneByteOp(OP_GROUP3_Ev,dst,GROUP3_OP_NOT);}voidnotl_m(int32_toffset,RegisterIDbase){spew("notl "MEM_ob,ADDR_ob(offset,base));m_formatter.oneByteOp(OP_GROUP3_Ev,offset,base,GROUP3_OP_NOT);}voidorl_rr(RegisterIDsrc,RegisterIDdst){spew("orl %s, %s",GPReg32Name(src),GPReg32Name(dst));m_formatter.oneByteOp(OP_OR_GvEv,src,dst);}voidorw_rr(RegisterIDsrc,RegisterIDdst){spew("orw %s, %s",GPReg16Name(src),GPReg16Name(dst));m_formatter.prefix(PRE_OPERAND_SIZE);m_formatter.oneByteOp(OP_OR_GvEv,src,dst);}voidorl_mr(int32_toffset,RegisterIDbase,RegisterIDdst){spew("orl "MEM_ob", %s",ADDR_ob(offset,base),GPReg32Name(dst));m_formatter.oneByteOp(OP_OR_GvEv,offset,base,dst);}voidorl_rm(RegisterIDsrc,int32_toffset,RegisterIDbase){spew("orl %s, "MEM_ob,GPReg32Name(src),ADDR_ob(offset,base));m_formatter.oneByteOp(OP_OR_EvGv,offset,base,src);}voidorw_rm(RegisterIDsrc,int32_toffset,RegisterIDbase){spew("orw %s, "MEM_ob,GPReg16Name(src),ADDR_ob(offset,base));m_formatter.prefix(PRE_OPERAND_SIZE);m_formatter.oneByteOp(OP_OR_EvGv,offset,base,src);}voidorl_rm(RegisterIDsrc,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("orl %s, "MEM_obs,GPReg32Name(src),ADDR_obs(offset,base,index,scale));m_formatter.oneByteOp(OP_OR_EvGv,offset,base,index,scale,src);}voidorw_rm(RegisterIDsrc,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("orw %s, "MEM_obs,GPReg16Name(src),ADDR_obs(offset,base,index,scale));m_formatter.prefix(PRE_OPERAND_SIZE);m_formatter.oneByteOp(OP_OR_EvGv,offset,base,index,scale,src);}voidorl_ir(int32_timm,RegisterIDdst){spew("orl $0x%x, %s",imm,GPReg32Name(dst));if(CAN_SIGN_EXTEND_8_32(imm)){m_formatter.oneByteOp(OP_GROUP1_EvIb,dst,GROUP1_OP_OR);m_formatter.immediate8s(imm);}else{if(dst==rax)m_formatter.oneByteOp(OP_OR_EAXIv);elsem_formatter.oneByteOp(OP_GROUP1_EvIz,dst,GROUP1_OP_OR);m_formatter.immediate32(imm);}}voidorw_ir(int32_timm,RegisterIDdst){spew("orw $0x%x, %s",int16_t(imm),GPReg16Name(dst));m_formatter.prefix(PRE_OPERAND_SIZE);if(CAN_SIGN_EXTEND_8_32(imm)){m_formatter.oneByteOp(OP_GROUP1_EvIb,dst,GROUP1_OP_OR);m_formatter.immediate8s(imm);}else{if(dst==rax)m_formatter.oneByteOp(OP_OR_EAXIv);elsem_formatter.oneByteOp(OP_GROUP1_EvIz,dst,GROUP1_OP_OR);m_formatter.immediate16(imm);}}voidorl_im(int32_timm,int32_toffset,RegisterIDbase){spew("orl $0x%x, "MEM_ob,imm,ADDR_ob(offset,base));if(CAN_SIGN_EXTEND_8_32(imm)){m_formatter.oneByteOp(OP_GROUP1_EvIb,offset,base,GROUP1_OP_OR);m_formatter.immediate8s(imm);}else{m_formatter.oneByteOp(OP_GROUP1_EvIz,offset,base,GROUP1_OP_OR);m_formatter.immediate32(imm);}}voidorw_im(int32_timm,int32_toffset,RegisterIDbase){spew("orw $0x%x, "MEM_ob,int16_t(imm),ADDR_ob(offset,base));m_formatter.prefix(PRE_OPERAND_SIZE);if(CAN_SIGN_EXTEND_8_32(imm)){m_formatter.oneByteOp(OP_GROUP1_EvIb,offset,base,GROUP1_OP_OR);m_formatter.immediate8s(imm);}else{m_formatter.oneByteOp(OP_GROUP1_EvIz,offset,base,GROUP1_OP_OR);m_formatter.immediate16(imm);}}voidorl_im(int32_timm,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("orl $%d, "MEM_obs,imm,ADDR_obs(offset,base,index,scale));if(CAN_SIGN_EXTEND_8_32(imm)){m_formatter.oneByteOp(OP_GROUP1_EvIb,offset,base,index,scale,GROUP1_OP_OR);m_formatter.immediate8s(imm);}else{m_formatter.oneByteOp(OP_GROUP1_EvIz,offset,base,index,scale,GROUP1_OP_OR);m_formatter.immediate32(imm);}}voidorw_im(int32_timm,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("orw $%d, "MEM_obs,int16_t(imm),ADDR_obs(offset,base,index,scale));m_formatter.prefix(PRE_OPERAND_SIZE);if(CAN_SIGN_EXTEND_8_32(imm)){m_formatter.oneByteOp(OP_GROUP1_EvIb,offset,base,index,scale,GROUP1_OP_OR);m_formatter.immediate8s(imm);}else{m_formatter.oneByteOp(OP_GROUP1_EvIz,offset,base,index,scale,GROUP1_OP_OR);m_formatter.immediate16(imm);}}voidsubl_rr(RegisterIDsrc,RegisterIDdst){spew("subl %s, %s",GPReg32Name(src),GPReg32Name(dst));m_formatter.oneByteOp(OP_SUB_GvEv,src,dst);}voidsubw_rr(RegisterIDsrc,RegisterIDdst){spew("subw %s, %s",GPReg16Name(src),GPReg16Name(dst));m_formatter.prefix(PRE_OPERAND_SIZE);m_formatter.oneByteOp(OP_SUB_GvEv,src,dst);}voidsubl_mr(int32_toffset,RegisterIDbase,RegisterIDdst){spew("subl "MEM_ob", %s",ADDR_ob(offset,base),GPReg32Name(dst));m_formatter.oneByteOp(OP_SUB_GvEv,offset,base,dst);}voidsubl_rm(RegisterIDsrc,int32_toffset,RegisterIDbase){spew("subl %s, "MEM_ob,GPReg32Name(src),ADDR_ob(offset,base));m_formatter.oneByteOp(OP_SUB_EvGv,offset,base,src);}voidsubw_rm(RegisterIDsrc,int32_toffset,RegisterIDbase){spew("subw %s, "MEM_ob,GPReg16Name(src),ADDR_ob(offset,base));m_formatter.prefix(PRE_OPERAND_SIZE);m_formatter.oneByteOp(OP_SUB_EvGv,offset,base,src);}voidsubl_rm(RegisterIDsrc,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("subl %s, "MEM_obs,GPReg32Name(src),ADDR_obs(offset,base,index,scale));m_formatter.oneByteOp(OP_SUB_EvGv,offset,base,index,scale,src);}voidsubw_rm(RegisterIDsrc,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("subw %s, "MEM_obs,GPReg16Name(src),ADDR_obs(offset,base,index,scale));m_formatter.prefix(PRE_OPERAND_SIZE);m_formatter.oneByteOp(OP_SUB_EvGv,offset,base,index,scale,src);}voidsubl_ir(int32_timm,RegisterIDdst){spew("subl $%d, %s",imm,GPReg32Name(dst));if(CAN_SIGN_EXTEND_8_32(imm)){m_formatter.oneByteOp(OP_GROUP1_EvIb,dst,GROUP1_OP_SUB);m_formatter.immediate8s(imm);}else{if(dst==rax)m_formatter.oneByteOp(OP_SUB_EAXIv);elsem_formatter.oneByteOp(OP_GROUP1_EvIz,dst,GROUP1_OP_SUB);m_formatter.immediate32(imm);}}voidsubw_ir(int32_timm,RegisterIDdst){spew("subw $%d, %s",int16_t(imm),GPReg16Name(dst));m_formatter.prefix(PRE_OPERAND_SIZE);if(CAN_SIGN_EXTEND_8_32(imm)){m_formatter.oneByteOp(OP_GROUP1_EvIb,dst,GROUP1_OP_SUB);m_formatter.immediate8s(imm);}else{if(dst==rax)m_formatter.oneByteOp(OP_SUB_EAXIv);elsem_formatter.oneByteOp(OP_GROUP1_EvIz,dst,GROUP1_OP_SUB);m_formatter.immediate16(imm);}}voidsubl_im(int32_timm,int32_toffset,RegisterIDbase){spew("subl $%d, "MEM_ob,imm,ADDR_ob(offset,base));if(CAN_SIGN_EXTEND_8_32(imm)){m_formatter.oneByteOp(OP_GROUP1_EvIb,offset,base,GROUP1_OP_SUB);m_formatter.immediate8s(imm);}else{m_formatter.oneByteOp(OP_GROUP1_EvIz,offset,base,GROUP1_OP_SUB);m_formatter.immediate32(imm);}}voidsubw_im(int32_timm,int32_toffset,RegisterIDbase){spew("subw $%d, "MEM_ob,int16_t(imm),ADDR_ob(offset,base));m_formatter.prefix(PRE_OPERAND_SIZE);if(CAN_SIGN_EXTEND_8_32(imm)){m_formatter.oneByteOp(OP_GROUP1_EvIb,offset,base,GROUP1_OP_SUB);m_formatter.immediate8s(imm);}else{m_formatter.oneByteOp(OP_GROUP1_EvIz,offset,base,GROUP1_OP_SUB);m_formatter.immediate16(imm);}}voidsubl_im(int32_timm,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("subl $%d, "MEM_obs,imm,ADDR_obs(offset,base,index,scale));if(CAN_SIGN_EXTEND_8_32(imm)){m_formatter.oneByteOp(OP_GROUP1_EvIb,offset,base,index,scale,GROUP1_OP_SUB);m_formatter.immediate8s(imm);}else{m_formatter.oneByteOp(OP_GROUP1_EvIz,offset,base,index,scale,GROUP1_OP_SUB);m_formatter.immediate32(imm);}}voidsubw_im(int32_timm,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("subw $%d, "MEM_obs,int16_t(imm),ADDR_obs(offset,base,index,scale));m_formatter.prefix(PRE_OPERAND_SIZE);if(CAN_SIGN_EXTEND_8_32(imm)){m_formatter.oneByteOp(OP_GROUP1_EvIb,offset,base,index,scale,GROUP1_OP_SUB);m_formatter.immediate8s(imm);}else{m_formatter.oneByteOp(OP_GROUP1_EvIz,offset,base,index,scale,GROUP1_OP_SUB);m_formatter.immediate16(imm);}}voidxorl_rr(RegisterIDsrc,RegisterIDdst){spew("xorl %s, %s",GPReg32Name(src),GPReg32Name(dst));m_formatter.oneByteOp(OP_XOR_GvEv,src,dst);}voidxorw_rr(RegisterIDsrc,RegisterIDdst){spew("xorw %s, %s",GPReg16Name(src),GPReg16Name(dst));m_formatter.prefix(PRE_OPERAND_SIZE);m_formatter.oneByteOp(OP_XOR_GvEv,src,dst);}voidxorl_mr(int32_toffset,RegisterIDbase,RegisterIDdst){spew("xorl "MEM_ob", %s",ADDR_ob(offset,base),GPReg32Name(dst));m_formatter.oneByteOp(OP_XOR_GvEv,offset,base,dst);}voidxorl_rm(RegisterIDsrc,int32_toffset,RegisterIDbase){spew("xorl %s, "MEM_ob,GPReg32Name(src),ADDR_ob(offset,base));m_formatter.oneByteOp(OP_XOR_EvGv,offset,base,src);}voidxorw_rm(RegisterIDsrc,int32_toffset,RegisterIDbase){spew("xorw %s, "MEM_ob,GPReg16Name(src),ADDR_ob(offset,base));m_formatter.prefix(PRE_OPERAND_SIZE);m_formatter.oneByteOp(OP_XOR_EvGv,offset,base,src);}voidxorl_rm(RegisterIDsrc,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("xorl %s, "MEM_obs,GPReg32Name(src),ADDR_obs(offset,base,index,scale));m_formatter.oneByteOp(OP_XOR_EvGv,offset,base,index,scale,src);}voidxorw_rm(RegisterIDsrc,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("xorw %s, "MEM_obs,GPReg16Name(src),ADDR_obs(offset,base,index,scale));m_formatter.prefix(PRE_OPERAND_SIZE);m_formatter.oneByteOp(OP_XOR_EvGv,offset,base,index,scale,src);}voidxorl_im(int32_timm,int32_toffset,RegisterIDbase){spew("xorl $0x%x, "MEM_ob,imm,ADDR_ob(offset,base));if(CAN_SIGN_EXTEND_8_32(imm)){m_formatter.oneByteOp(OP_GROUP1_EvIb,offset,base,GROUP1_OP_XOR);m_formatter.immediate8s(imm);}else{m_formatter.oneByteOp(OP_GROUP1_EvIz,offset,base,GROUP1_OP_XOR);m_formatter.immediate32(imm);}}voidxorw_im(int32_timm,int32_toffset,RegisterIDbase){spew("xorw $0x%x, "MEM_ob,int16_t(imm),ADDR_ob(offset,base));m_formatter.prefix(PRE_OPERAND_SIZE);if(CAN_SIGN_EXTEND_8_32(imm)){m_formatter.oneByteOp(OP_GROUP1_EvIb,offset,base,GROUP1_OP_XOR);m_formatter.immediate8s(imm);}else{m_formatter.oneByteOp(OP_GROUP1_EvIz,offset,base,GROUP1_OP_XOR);m_formatter.immediate16(imm);}}voidxorl_im(int32_timm,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("xorl $%d, "MEM_obs,imm,ADDR_obs(offset,base,index,scale));if(CAN_SIGN_EXTEND_8_32(imm)){m_formatter.oneByteOp(OP_GROUP1_EvIb,offset,base,index,scale,GROUP1_OP_XOR);m_formatter.immediate8s(imm);}else{m_formatter.oneByteOp(OP_GROUP1_EvIz,offset,base,index,scale,GROUP1_OP_XOR);m_formatter.immediate32(imm);}}voidxorw_im(int32_timm,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("xorw $%d, "MEM_obs,int16_t(imm),ADDR_obs(offset,base,index,scale));m_formatter.prefix(PRE_OPERAND_SIZE);if(CAN_SIGN_EXTEND_8_32(imm)){m_formatter.oneByteOp(OP_GROUP1_EvIb,offset,base,index,scale,GROUP1_OP_XOR);m_formatter.immediate8s(imm);}else{m_formatter.oneByteOp(OP_GROUP1_EvIz,offset,base,index,scale,GROUP1_OP_XOR);m_formatter.immediate16(imm);}}voidxorl_ir(int32_timm,RegisterIDdst){spew("xorl $%d, %s",imm,GPReg32Name(dst));if(CAN_SIGN_EXTEND_8_32(imm)){m_formatter.oneByteOp(OP_GROUP1_EvIb,dst,GROUP1_OP_XOR);m_formatter.immediate8s(imm);}else{if(dst==rax)m_formatter.oneByteOp(OP_XOR_EAXIv);elsem_formatter.oneByteOp(OP_GROUP1_EvIz,dst,GROUP1_OP_XOR);m_formatter.immediate32(imm);}}voidxorw_ir(int32_timm,RegisterIDdst){spew("xorw $%d, %s",int16_t(imm),GPReg16Name(dst));m_formatter.prefix(PRE_OPERAND_SIZE);if(CAN_SIGN_EXTEND_8_32(imm)){m_formatter.oneByteOp(OP_GROUP1_EvIb,dst,GROUP1_OP_XOR);m_formatter.immediate8s(imm);}else{if(dst==rax)m_formatter.oneByteOp(OP_XOR_EAXIv);elsem_formatter.oneByteOp(OP_GROUP1_EvIz,dst,GROUP1_OP_XOR);m_formatter.immediate16(imm);}}voidsarl_ir(int32_timm,RegisterIDdst){MOZ_ASSERT(imm<32);spew("sarl $%d, %s",imm,GPReg32Name(dst));if(imm==1)m_formatter.oneByteOp(OP_GROUP2_Ev1,dst,GROUP2_OP_SAR);else{m_formatter.oneByteOp(OP_GROUP2_EvIb,dst,GROUP2_OP_SAR);m_formatter.immediate8u(imm);}}voidsarl_CLr(RegisterIDdst){spew("sarl %%cl, %s",GPReg32Name(dst));m_formatter.oneByteOp(OP_GROUP2_EvCL,dst,GROUP2_OP_SAR);}voidshrl_ir(int32_timm,RegisterIDdst){MOZ_ASSERT(imm<32);spew("shrl $%d, %s",imm,GPReg32Name(dst));if(imm==1)m_formatter.oneByteOp(OP_GROUP2_Ev1,dst,GROUP2_OP_SHR);else{m_formatter.oneByteOp(OP_GROUP2_EvIb,dst,GROUP2_OP_SHR);m_formatter.immediate8u(imm);}}voidshrl_CLr(RegisterIDdst){spew("shrl %%cl, %s",GPReg32Name(dst));m_formatter.oneByteOp(OP_GROUP2_EvCL,dst,GROUP2_OP_SHR);}voidshrdl_CLr(RegisterIDsrc,RegisterIDdst){spew("shrdl %%cl, %s, %s",GPReg32Name(src),GPReg32Name(dst));m_formatter.twoByteOp(OP2_SHRD_GvEv,dst,src);}voidshldl_CLr(RegisterIDsrc,RegisterIDdst){spew("shldl %%cl, %s, %s",GPReg32Name(src),GPReg32Name(dst));m_formatter.twoByteOp(OP2_SHLD_GvEv,dst,src);}voidshll_ir(int32_timm,RegisterIDdst){MOZ_ASSERT(imm<32);spew("shll $%d, %s",imm,GPReg32Name(dst));if(imm==1)m_formatter.oneByteOp(OP_GROUP2_Ev1,dst,GROUP2_OP_SHL);else{m_formatter.oneByteOp(OP_GROUP2_EvIb,dst,GROUP2_OP_SHL);m_formatter.immediate8u(imm);}}voidshll_CLr(RegisterIDdst){spew("shll %%cl, %s",GPReg32Name(dst));m_formatter.oneByteOp(OP_GROUP2_EvCL,dst,GROUP2_OP_SHL);}voidroll_ir(int32_timm,RegisterIDdst){MOZ_ASSERT(imm<32);spew("roll $%d, %s",imm,GPReg32Name(dst));if(imm==1)m_formatter.oneByteOp(OP_GROUP2_Ev1,dst,GROUP2_OP_ROL);else{m_formatter.oneByteOp(OP_GROUP2_EvIb,dst,GROUP2_OP_ROL);m_formatter.immediate8u(imm);}}voidroll_CLr(RegisterIDdst){spew("roll %%cl, %s",GPReg32Name(dst));m_formatter.oneByteOp(OP_GROUP2_EvCL,dst,GROUP2_OP_ROL);}voidrorl_ir(int32_timm,RegisterIDdst){MOZ_ASSERT(imm<32);spew("rorl $%d, %s",imm,GPReg32Name(dst));if(imm==1)m_formatter.oneByteOp(OP_GROUP2_Ev1,dst,GROUP2_OP_ROR);else{m_formatter.oneByteOp(OP_GROUP2_EvIb,dst,GROUP2_OP_ROR);m_formatter.immediate8u(imm);}}voidrorl_CLr(RegisterIDdst){spew("rorl %%cl, %s",GPReg32Name(dst));m_formatter.oneByteOp(OP_GROUP2_EvCL,dst,GROUP2_OP_ROR);}voidbsrl_rr(RegisterIDsrc,RegisterIDdst){spew("bsrl %s, %s",GPReg32Name(src),GPReg32Name(dst));m_formatter.twoByteOp(OP2_BSR_GvEv,src,dst);}voidbsfl_rr(RegisterIDsrc,RegisterIDdst){spew("bsfl %s, %s",GPReg32Name(src),GPReg32Name(dst));m_formatter.twoByteOp(OP2_BSF_GvEv,src,dst);}voidpopcntl_rr(RegisterIDsrc,RegisterIDdst){spew("popcntl %s, %s",GPReg32Name(src),GPReg32Name(dst));m_formatter.legacySSEPrefix(VEX_SS);m_formatter.twoByteOp(OP2_POPCNT_GvEv,src,dst);}voidimull_rr(RegisterIDsrc,RegisterIDdst){spew("imull %s, %s",GPReg32Name(src),GPReg32Name(dst));m_formatter.twoByteOp(OP2_IMUL_GvEv,src,dst);}voidimull_r(RegisterIDmultiplier){spew("imull %s",GPReg32Name(multiplier));m_formatter.oneByteOp(OP_GROUP3_Ev,multiplier,GROUP3_OP_IMUL);}voidimull_mr(int32_toffset,RegisterIDbase,RegisterIDdst){spew("imull "MEM_ob", %s",ADDR_ob(offset,base),GPReg32Name(dst));m_formatter.twoByteOp(OP2_IMUL_GvEv,offset,base,dst);}voidimull_ir(int32_tvalue,RegisterIDsrc,RegisterIDdst){spew("imull $%d, %s, %s",value,GPReg32Name(src),GPReg32Name(dst));if(CAN_SIGN_EXTEND_8_32(value)){m_formatter.oneByteOp(OP_IMUL_GvEvIb,src,dst);m_formatter.immediate8s(value);}else{m_formatter.oneByteOp(OP_IMUL_GvEvIz,src,dst);m_formatter.immediate32(value);}}voidmull_r(RegisterIDmultiplier){spew("mull %s",GPReg32Name(multiplier));m_formatter.oneByteOp(OP_GROUP3_Ev,multiplier,GROUP3_OP_MUL);}voididivl_r(RegisterIDdivisor){spew("idivl %s",GPReg32Name(divisor));m_formatter.oneByteOp(OP_GROUP3_Ev,divisor,GROUP3_OP_IDIV);}voiddivl_r(RegisterIDdivisor){spew("div %s",GPReg32Name(divisor));m_formatter.oneByteOp(OP_GROUP3_Ev,divisor,GROUP3_OP_DIV);}voidprefix_lock(){spew("lock");m_formatter.oneByteOp(PRE_LOCK);}voidprefix_16_for_32(){m_formatter.prefix(PRE_OPERAND_SIZE);}voidincl_m32(int32_toffset,RegisterIDbase){spew("incl "MEM_ob,ADDR_ob(offset,base));m_formatter.oneByteOp(OP_GROUP5_Ev,offset,base,GROUP5_OP_INC);}voiddecl_m32(int32_toffset,RegisterIDbase){spew("decl "MEM_ob,ADDR_ob(offset,base));m_formatter.oneByteOp(OP_GROUP5_Ev,offset,base,GROUP5_OP_DEC);}// Note that CMPXCHG performs comparison against REG = %al/%ax/%eax/%rax.// If %REG == [%base+offset], then %src -> [%base+offset].// Otherwise, [%base+offset] -> %REG.// For the 8-bit operations src must also be an 8-bit register.voidcmpxchgb(RegisterIDsrc,int32_toffset,RegisterIDbase){spew("cmpxchgb %s, "MEM_ob,GPReg8Name(src),ADDR_ob(offset,base));m_formatter.twoByteOp8(OP2_CMPXCHG_GvEb,offset,base,src);}voidcmpxchgb(RegisterIDsrc,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("cmpxchgb %s, "MEM_obs,GPReg8Name(src),ADDR_obs(offset,base,index,scale));m_formatter.twoByteOp8(OP2_CMPXCHG_GvEb,offset,base,index,scale,src);}voidcmpxchgw(RegisterIDsrc,int32_toffset,RegisterIDbase){spew("cmpxchgw %s, "MEM_ob,GPReg16Name(src),ADDR_ob(offset,base));m_formatter.prefix(PRE_OPERAND_SIZE);m_formatter.twoByteOp(OP2_CMPXCHG_GvEw,offset,base,src);}voidcmpxchgw(RegisterIDsrc,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("cmpxchgw %s, "MEM_obs,GPReg16Name(src),ADDR_obs(offset,base,index,scale));m_formatter.prefix(PRE_OPERAND_SIZE);m_formatter.twoByteOp(OP2_CMPXCHG_GvEw,offset,base,index,scale,src);}voidcmpxchgl(RegisterIDsrc,int32_toffset,RegisterIDbase){spew("cmpxchgl %s, "MEM_ob,GPReg32Name(src),ADDR_ob(offset,base));m_formatter.twoByteOp(OP2_CMPXCHG_GvEw,offset,base,src);}voidcmpxchgl(RegisterIDsrc,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("cmpxchgl %s, "MEM_obs,GPReg32Name(src),ADDR_obs(offset,base,index,scale));m_formatter.twoByteOp(OP2_CMPXCHG_GvEw,offset,base,index,scale,src);}// Comparisons:voidcmpl_rr(RegisterIDrhs,RegisterIDlhs){spew("cmpl %s, %s",GPReg32Name(rhs),GPReg32Name(lhs));m_formatter.oneByteOp(OP_CMP_GvEv,rhs,lhs);}voidcmpl_rm(RegisterIDrhs,int32_toffset,RegisterIDbase){spew("cmpl %s, "MEM_ob,GPReg32Name(rhs),ADDR_ob(offset,base));m_formatter.oneByteOp(OP_CMP_EvGv,offset,base,rhs);}voidcmpl_mr(int32_toffset,RegisterIDbase,RegisterIDlhs){spew("cmpl "MEM_ob", %s",ADDR_ob(offset,base),GPReg32Name(lhs));m_formatter.oneByteOp(OP_CMP_GvEv,offset,base,lhs);}voidcmpl_mr(constvoid*address,RegisterIDlhs){spew("cmpl %p, %s",address,GPReg32Name(lhs));m_formatter.oneByteOp(OP_CMP_GvEv,address,lhs);}voidcmpl_ir(int32_trhs,RegisterIDlhs){if(rhs==0){testl_rr(lhs,lhs);return;}spew("cmpl $0x%x, %s",rhs,GPReg32Name(lhs));if(CAN_SIGN_EXTEND_8_32(rhs)){m_formatter.oneByteOp(OP_GROUP1_EvIb,lhs,GROUP1_OP_CMP);m_formatter.immediate8s(rhs);}else{if(lhs==rax)m_formatter.oneByteOp(OP_CMP_EAXIv);elsem_formatter.oneByteOp(OP_GROUP1_EvIz,lhs,GROUP1_OP_CMP);m_formatter.immediate32(rhs);}}voidcmpl_i32r(int32_trhs,RegisterIDlhs){spew("cmpl $0x%04x, %s",rhs,GPReg32Name(lhs));if(lhs==rax)m_formatter.oneByteOp(OP_CMP_EAXIv);elsem_formatter.oneByteOp(OP_GROUP1_EvIz,lhs,GROUP1_OP_CMP);m_formatter.immediate32(rhs);}voidcmpl_im(int32_trhs,int32_toffset,RegisterIDbase){spew("cmpl $0x%x, "MEM_ob,rhs,ADDR_ob(offset,base));if(CAN_SIGN_EXTEND_8_32(rhs)){m_formatter.oneByteOp(OP_GROUP1_EvIb,offset,base,GROUP1_OP_CMP);m_formatter.immediate8s(rhs);}else{m_formatter.oneByteOp(OP_GROUP1_EvIz,offset,base,GROUP1_OP_CMP);m_formatter.immediate32(rhs);}}voidcmpb_im(int32_trhs,int32_toffset,RegisterIDbase){spew("cmpb $0x%x, "MEM_ob,rhs,ADDR_ob(offset,base));m_formatter.oneByteOp(OP_GROUP1_EbIb,offset,base,GROUP1_OP_CMP);m_formatter.immediate8(rhs);}voidcmpb_im(int32_trhs,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("cmpb $0x%x, "MEM_obs,rhs,ADDR_obs(offset,base,index,scale));m_formatter.oneByteOp(OP_GROUP1_EbIb,offset,base,index,scale,GROUP1_OP_CMP);m_formatter.immediate8(rhs);}voidcmpl_im(int32_trhs,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("cmpl $0x%x, "MEM_o32b,rhs,ADDR_o32b(offset,base));if(CAN_SIGN_EXTEND_8_32(rhs)){m_formatter.oneByteOp(OP_GROUP1_EvIb,offset,base,index,scale,GROUP1_OP_CMP);m_formatter.immediate8s(rhs);}else{m_formatter.oneByteOp(OP_GROUP1_EvIz,offset,base,index,scale,GROUP1_OP_CMP);m_formatter.immediate32(rhs);}}MOZ_MUST_USEJmpSrccmpl_im_disp32(int32_trhs,int32_toffset,RegisterIDbase){spew("cmpl $0x%x, "MEM_o32b,rhs,ADDR_o32b(offset,base));JmpSrcr;if(CAN_SIGN_EXTEND_8_32(rhs)){m_formatter.oneByteOp_disp32(OP_GROUP1_EvIb,offset,base,GROUP1_OP_CMP);r=JmpSrc(m_formatter.size());m_formatter.immediate8s(rhs);}else{m_formatter.oneByteOp_disp32(OP_GROUP1_EvIz,offset,base,GROUP1_OP_CMP);r=JmpSrc(m_formatter.size());m_formatter.immediate32(rhs);}returnr;}MOZ_MUST_USEJmpSrccmpl_im_disp32(int32_trhs,constvoid*addr){spew("cmpl $0x%x, %p",rhs,addr);JmpSrcr;if(CAN_SIGN_EXTEND_8_32(rhs)){m_formatter.oneByteOp_disp32(OP_GROUP1_EvIb,addr,GROUP1_OP_CMP);r=JmpSrc(m_formatter.size());m_formatter.immediate8s(rhs);}else{m_formatter.oneByteOp_disp32(OP_GROUP1_EvIz,addr,GROUP1_OP_CMP);r=JmpSrc(m_formatter.size());m_formatter.immediate32(rhs);}returnr;}voidcmpl_i32m(int32_trhs,int32_toffset,RegisterIDbase){spew("cmpl $0x%04x, "MEM_ob,rhs,ADDR_ob(offset,base));m_formatter.oneByteOp(OP_GROUP1_EvIz,offset,base,GROUP1_OP_CMP);m_formatter.immediate32(rhs);}voidcmpl_i32m(int32_trhs,constvoid*addr){spew("cmpl $0x%04x, %p",rhs,addr);m_formatter.oneByteOp(OP_GROUP1_EvIz,addr,GROUP1_OP_CMP);m_formatter.immediate32(rhs);}voidcmpl_rm(RegisterIDrhs,constvoid*addr){spew("cmpl %s, %p",GPReg32Name(rhs),addr);m_formatter.oneByteOp(OP_CMP_EvGv,addr,rhs);}voidcmpl_rm_disp32(RegisterIDrhs,constvoid*addr){spew("cmpl %s, %p",GPReg32Name(rhs),addr);m_formatter.oneByteOp_disp32(OP_CMP_EvGv,addr,rhs);}voidcmpl_im(int32_trhs,constvoid*addr){spew("cmpl $0x%x, %p",rhs,addr);if(CAN_SIGN_EXTEND_8_32(rhs)){m_formatter.oneByteOp(OP_GROUP1_EvIb,addr,GROUP1_OP_CMP);m_formatter.immediate8s(rhs);}else{m_formatter.oneByteOp(OP_GROUP1_EvIz,addr,GROUP1_OP_CMP);m_formatter.immediate32(rhs);}}voidcmpw_rr(RegisterIDrhs,RegisterIDlhs){spew("cmpw %s, %s",GPReg16Name(rhs),GPReg16Name(lhs));m_formatter.prefix(PRE_OPERAND_SIZE);m_formatter.oneByteOp(OP_CMP_GvEv,rhs,lhs);}voidcmpw_rm(RegisterIDrhs,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("cmpw %s, "MEM_obs,GPReg16Name(rhs),ADDR_obs(offset,base,index,scale));m_formatter.prefix(PRE_OPERAND_SIZE);m_formatter.oneByteOp(OP_CMP_EvGv,offset,base,index,scale,rhs);}voidcmpw_im(int32_timm,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("cmpw $%d, "MEM_obs,imm,ADDR_obs(offset,base,index,scale));if(CAN_SIGN_EXTEND_8_32(imm)){m_formatter.prefix(PRE_OPERAND_SIZE);m_formatter.oneByteOp(OP_GROUP1_EvIb,offset,base,index,scale,GROUP1_OP_CMP);m_formatter.immediate8s(imm);}else{m_formatter.prefix(PRE_OPERAND_SIZE);m_formatter.oneByteOp(OP_GROUP1_EvIz,offset,base,index,scale,GROUP1_OP_CMP);m_formatter.immediate16(imm);}}voidtestl_rr(RegisterIDrhs,RegisterIDlhs){spew("testl %s, %s",GPReg32Name(rhs),GPReg32Name(lhs));m_formatter.oneByteOp(OP_TEST_EvGv,lhs,rhs);}voidtestb_rr(RegisterIDrhs,RegisterIDlhs){spew("testb %s, %s",GPReg8Name(rhs),GPReg8Name(lhs));m_formatter.oneByteOp(OP_TEST_EbGb,lhs,rhs);}voidtestl_ir(int32_trhs,RegisterIDlhs){// If the mask fits in an 8-bit immediate, we can use testb with an// 8-bit subreg.if(CAN_ZERO_EXTEND_8_32(rhs)&&HasSubregL(lhs)){testb_ir(rhs,lhs);return;}// If the mask is a subset of 0xff00, we can use testb with an h reg, if// one happens to be available.if(CAN_ZERO_EXTEND_8H_32(rhs)&&HasSubregH(lhs)){testb_ir_norex(rhs>>8,GetSubregH(lhs));return;}spew("testl $0x%x, %s",rhs,GPReg32Name(lhs));if(lhs==rax)m_formatter.oneByteOp(OP_TEST_EAXIv);elsem_formatter.oneByteOp(OP_GROUP3_EvIz,lhs,GROUP3_OP_TEST);m_formatter.immediate32(rhs);}voidtestl_i32m(int32_trhs,int32_toffset,RegisterIDbase){spew("testl $0x%x, "MEM_ob,rhs,ADDR_ob(offset,base));m_formatter.oneByteOp(OP_GROUP3_EvIz,offset,base,GROUP3_OP_TEST);m_formatter.immediate32(rhs);}voidtestl_i32m(int32_trhs,constvoid*addr){spew("testl $0x%x, %p",rhs,addr);m_formatter.oneByteOp(OP_GROUP3_EvIz,addr,GROUP3_OP_TEST);m_formatter.immediate32(rhs);}voidtestb_im(int32_trhs,int32_toffset,RegisterIDbase){spew("testb $0x%x, "MEM_ob,rhs,ADDR_ob(offset,base));m_formatter.oneByteOp(OP_GROUP3_EbIb,offset,base,GROUP3_OP_TEST);m_formatter.immediate8(rhs);}voidtestb_im(int32_trhs,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("testb $0x%x, "MEM_obs,rhs,ADDR_obs(offset,base,index,scale));m_formatter.oneByteOp(OP_GROUP3_EbIb,offset,base,index,scale,GROUP3_OP_TEST);m_formatter.immediate8(rhs);}voidtestl_i32m(int32_trhs,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("testl $0x%4x, "MEM_obs,rhs,ADDR_obs(offset,base,index,scale));m_formatter.oneByteOp(OP_GROUP3_EvIz,offset,base,index,scale,GROUP3_OP_TEST);m_formatter.immediate32(rhs);}voidtestw_rr(RegisterIDrhs,RegisterIDlhs){spew("testw %s, %s",GPReg16Name(rhs),GPReg16Name(lhs));m_formatter.prefix(PRE_OPERAND_SIZE);m_formatter.oneByteOp(OP_TEST_EvGv,lhs,rhs);}voidtestb_ir(int32_trhs,RegisterIDlhs){spew("testb $0x%x, %s",rhs,GPReg8Name(lhs));if(lhs==rax)m_formatter.oneByteOp8(OP_TEST_EAXIb);elsem_formatter.oneByteOp8(OP_GROUP3_EbIb,lhs,GROUP3_OP_TEST);m_formatter.immediate8(rhs);}// Like testb_ir, but never emits a REX prefix. This may be used to// reference ah..bh.voidtestb_ir_norex(int32_trhs,HRegisterIDlhs){spew("testb $0x%x, %s",rhs,HRegName8(lhs));m_formatter.oneByteOp8_norex(OP_GROUP3_EbIb,lhs,GROUP3_OP_TEST);m_formatter.immediate8(rhs);}voidsetCC_r(Conditioncond,RegisterIDlhs){spew("set%s %s",CCName(cond),GPReg8Name(lhs));m_formatter.twoByteOp8(setccOpcode(cond),lhs,(GroupOpcodeID)0);}voidsete_r(RegisterIDdst){setCC_r(ConditionE,dst);}voidsetz_r(RegisterIDdst){sete_r(dst);}voidsetne_r(RegisterIDdst){setCC_r(ConditionNE,dst);}voidsetnz_r(RegisterIDdst){setne_r(dst);}// Various move ops:voidcdq(){spew("cdq ");m_formatter.oneByteOp(OP_CDQ);}voidxchgb_rm(RegisterIDsrc,int32_toffset,RegisterIDbase){spew("xchgb %s, "MEM_ob,GPReg8Name(src),ADDR_ob(offset,base));m_formatter.oneByteOp8(OP_XCHG_GbEb,offset,base,src);}voidxchgb_rm(RegisterIDsrc,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("xchgb %s, "MEM_obs,GPReg8Name(src),ADDR_obs(offset,base,index,scale));m_formatter.oneByteOp8(OP_XCHG_GbEb,offset,base,index,scale,src);}voidxchgw_rm(RegisterIDsrc,int32_toffset,RegisterIDbase){spew("xchgw %s, "MEM_ob,GPReg16Name(src),ADDR_ob(offset,base));m_formatter.prefix(PRE_OPERAND_SIZE);m_formatter.oneByteOp(OP_XCHG_GvEv,offset,base,src);}voidxchgw_rm(RegisterIDsrc,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("xchgw %s, "MEM_obs,GPReg16Name(src),ADDR_obs(offset,base,index,scale));m_formatter.prefix(PRE_OPERAND_SIZE);m_formatter.oneByteOp(OP_XCHG_GvEv,offset,base,index,scale,src);}voidxchgl_rr(RegisterIDsrc,RegisterIDdst){spew("xchgl %s, %s",GPReg32Name(src),GPReg32Name(dst));m_formatter.oneByteOp(OP_XCHG_GvEv,src,dst);}voidxchgl_rm(RegisterIDsrc,int32_toffset,RegisterIDbase){spew("xchgl %s, "MEM_ob,GPReg32Name(src),ADDR_ob(offset,base));m_formatter.oneByteOp(OP_XCHG_GvEv,offset,base,src);}voidxchgl_rm(RegisterIDsrc,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("xchgl %s, "MEM_obs,GPReg32Name(src),ADDR_obs(offset,base,index,scale));m_formatter.oneByteOp(OP_XCHG_GvEv,offset,base,index,scale,src);}voidcmovz_rr(RegisterIDsrc,RegisterIDdst){spew("cmovz %s, %s",GPReg16Name(src),GPReg32Name(dst));m_formatter.twoByteOp(OP2_CMOVZ_GvEv,src,dst);}voidcmovz_mr(int32_toffset,RegisterIDbase,RegisterIDdst){spew("cmovz "MEM_ob", %s",ADDR_ob(offset,base),GPReg32Name(dst));m_formatter.twoByteOp(OP2_CMOVZ_GvEv,offset,base,dst);}voidcmovz_mr(int32_toffset,RegisterIDbase,RegisterIDindex,intscale,RegisterIDdst){spew("cmovz "MEM_obs", %s",ADDR_obs(offset,base,index,scale),GPReg32Name(dst));m_formatter.twoByteOp(OP2_CMOVZ_GvEv,offset,base,index,scale,dst);}voidmovl_rr(RegisterIDsrc,RegisterIDdst){spew("movl %s, %s",GPReg32Name(src),GPReg32Name(dst));m_formatter.oneByteOp(OP_MOV_GvEv,src,dst);}voidmovw_rm(RegisterIDsrc,int32_toffset,RegisterIDbase){spew("movw %s, "MEM_ob,GPReg16Name(src),ADDR_ob(offset,base));m_formatter.prefix(PRE_OPERAND_SIZE);m_formatter.oneByteOp(OP_MOV_EvGv,offset,base,src);}voidmovw_rm_disp32(RegisterIDsrc,int32_toffset,RegisterIDbase){spew("movw %s, "MEM_o32b,GPReg16Name(src),ADDR_o32b(offset,base));m_formatter.prefix(PRE_OPERAND_SIZE);m_formatter.oneByteOp_disp32(OP_MOV_EvGv,offset,base,src);}voidmovw_rm(RegisterIDsrc,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("movw %s, "MEM_obs,GPReg16Name(src),ADDR_obs(offset,base,index,scale));m_formatter.prefix(PRE_OPERAND_SIZE);m_formatter.oneByteOp(OP_MOV_EvGv,offset,base,index,scale,src);}voidmovw_rm(RegisterIDsrc,constvoid*addr){spew("movw %s, %p",GPReg16Name(src),addr);m_formatter.prefix(PRE_OPERAND_SIZE);m_formatter.oneByteOp_disp32(OP_MOV_EvGv,addr,src);}voidmovl_rm(RegisterIDsrc,int32_toffset,RegisterIDbase){spew("movl %s, "MEM_ob,GPReg32Name(src),ADDR_ob(offset,base));m_formatter.oneByteOp(OP_MOV_EvGv,offset,base,src);}voidmovl_rm_disp32(RegisterIDsrc,int32_toffset,RegisterIDbase){spew("movl %s, "MEM_o32b,GPReg32Name(src),ADDR_o32b(offset,base));m_formatter.oneByteOp_disp32(OP_MOV_EvGv,offset,base,src);}voidmovl_rm(RegisterIDsrc,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("movl %s, "MEM_obs,GPReg32Name(src),ADDR_obs(offset,base,index,scale));m_formatter.oneByteOp(OP_MOV_EvGv,offset,base,index,scale,src);}voidmovl_mEAX(constvoid*addr){#ifdef JS_CODEGEN_X64if(IsAddressImmediate(addr)){movl_mr(addr,rax);return;}#endif#ifdef JS_CODEGEN_X64spew("movabs %p, %%eax",addr);#elsespew("movl %p, %%eax",addr);#endifm_formatter.oneByteOp(OP_MOV_EAXOv);#ifdef JS_CODEGEN_X64m_formatter.immediate64(reinterpret_cast<int64_t>(addr));#elsem_formatter.immediate32(reinterpret_cast<int32_t>(addr));#endif}voidmovl_mr(int32_toffset,RegisterIDbase,RegisterIDdst){spew("movl "MEM_ob", %s",ADDR_ob(offset,base),GPReg32Name(dst));m_formatter.oneByteOp(OP_MOV_GvEv,offset,base,dst);}voidmovl_mr_disp32(int32_toffset,RegisterIDbase,RegisterIDdst){spew("movl "MEM_o32b", %s",ADDR_o32b(offset,base),GPReg32Name(dst));m_formatter.oneByteOp_disp32(OP_MOV_GvEv,offset,base,dst);}voidmovl_mr(constvoid*base,RegisterIDindex,intscale,RegisterIDdst){int32_tdisp=AddressImmediate(base);spew("movl "MEM_os", %s",ADDR_os(disp,index,scale),GPReg32Name(dst));m_formatter.oneByteOp_disp32(OP_MOV_GvEv,disp,index,scale,dst);}voidmovl_mr(int32_toffset,RegisterIDbase,RegisterIDindex,intscale,RegisterIDdst){spew("movl "MEM_obs", %s",ADDR_obs(offset,base,index,scale),GPReg32Name(dst));m_formatter.oneByteOp(OP_MOV_GvEv,offset,base,index,scale,dst);}voidmovl_mr(constvoid*addr,RegisterIDdst){if(dst==rax#ifdef JS_CODEGEN_X64&&!IsAddressImmediate(addr)#endif){movl_mEAX(addr);return;}spew("movl %p, %s",addr,GPReg32Name(dst));m_formatter.oneByteOp(OP_MOV_GvEv,addr,dst);}voidmovl_i32r(int32_timm,RegisterIDdst){spew("movl $0x%x, %s",imm,GPReg32Name(dst));m_formatter.oneByteOp(OP_MOV_EAXIv,dst);m_formatter.immediate32(imm);}voidmovb_ir(int32_timm,RegisterIDreg){spew("movb $0x%x, %s",imm,GPReg8Name(reg));m_formatter.oneByteOp8(OP_MOV_EbIb,reg);m_formatter.immediate8(imm);}voidmovb_im(int32_timm,int32_toffset,RegisterIDbase){spew("movb $0x%x, "MEM_ob,imm,ADDR_ob(offset,base));m_formatter.oneByteOp(OP_GROUP11_EvIb,offset,base,GROUP11_MOV);m_formatter.immediate8(imm);}voidmovb_im(int32_timm,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("movb $0x%x, "MEM_obs,imm,ADDR_obs(offset,base,index,scale));m_formatter.oneByteOp(OP_GROUP11_EvIb,offset,base,index,scale,GROUP11_MOV);m_formatter.immediate8(imm);}voidmovb_im(int32_timm,constvoid*addr){spew("movb $%d, %p",imm,addr);m_formatter.oneByteOp_disp32(OP_GROUP11_EvIb,addr,GROUP11_MOV);m_formatter.immediate8(imm);}voidmovw_im(int32_timm,int32_toffset,RegisterIDbase){spew("movw $0x%x, "MEM_ob,imm,ADDR_ob(offset,base));m_formatter.prefix(PRE_OPERAND_SIZE);m_formatter.oneByteOp(OP_GROUP11_EvIz,offset,base,GROUP11_MOV);m_formatter.immediate16(imm);}voidmovw_im(int32_timm,constvoid*addr){spew("movw $%d, %p",imm,addr);m_formatter.prefix(PRE_OPERAND_SIZE);m_formatter.oneByteOp_disp32(OP_GROUP11_EvIz,addr,GROUP11_MOV);m_formatter.immediate16(imm);}voidmovl_i32m(int32_timm,int32_toffset,RegisterIDbase){spew("movl $0x%x, "MEM_ob,imm,ADDR_ob(offset,base));m_formatter.oneByteOp(OP_GROUP11_EvIz,offset,base,GROUP11_MOV);m_formatter.immediate32(imm);}voidmovw_im(int32_timm,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("movw $0x%x, "MEM_obs,imm,ADDR_obs(offset,base,index,scale));m_formatter.prefix(PRE_OPERAND_SIZE);m_formatter.oneByteOp(OP_GROUP11_EvIz,offset,base,index,scale,GROUP11_MOV);m_formatter.immediate16(imm);}voidmovl_i32m(int32_timm,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("movl $0x%x, "MEM_obs,imm,ADDR_obs(offset,base,index,scale));m_formatter.oneByteOp(OP_GROUP11_EvIz,offset,base,index,scale,GROUP11_MOV);m_formatter.immediate32(imm);}voidmovl_EAXm(constvoid*addr){#ifdef JS_CODEGEN_X64if(IsAddressImmediate(addr)){movl_rm(rax,addr);return;}#endifspew("movl %%eax, %p",addr);m_formatter.oneByteOp(OP_MOV_OvEAX);#ifdef JS_CODEGEN_X64m_formatter.immediate64(reinterpret_cast<int64_t>(addr));#elsem_formatter.immediate32(reinterpret_cast<int32_t>(addr));#endif}voidvmovq_rm(XMMRegisterIDsrc,int32_toffset,RegisterIDbase){// vmovq_rm can be encoded either as a true vmovq or as a vmovd with a// REX prefix modifying it to be 64-bit. We choose the vmovq encoding// because it's smaller (when it doesn't need a REX prefix for other// reasons) and because it works on 32-bit x86 too.twoByteOpSimd("vmovq",VEX_PD,OP2_MOVQ_WdVd,offset,base,invalid_xmm,src);}voidvmovq_rm_disp32(XMMRegisterIDsrc,int32_toffset,RegisterIDbase){twoByteOpSimd_disp32("vmovq",VEX_PD,OP2_MOVQ_WdVd,offset,base,invalid_xmm,src);}voidvmovq_rm(XMMRegisterIDsrc,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){twoByteOpSimd("vmovq",VEX_PD,OP2_MOVQ_WdVd,offset,base,index,scale,invalid_xmm,src);}voidvmovq_rm(XMMRegisterIDsrc,constvoid*addr){twoByteOpSimd("vmovq",VEX_PD,OP2_MOVQ_WdVd,addr,invalid_xmm,src);}voidvmovq_mr(int32_toffset,RegisterIDbase,XMMRegisterIDdst){// vmovq_mr can be encoded either as a true vmovq or as a vmovd with a// REX prefix modifying it to be 64-bit. We choose the vmovq encoding// because it's smaller (when it doesn't need a REX prefix for other// reasons) and because it works on 32-bit x86 too.twoByteOpSimd("vmovq",VEX_SS,OP2_MOVQ_VdWd,offset,base,invalid_xmm,dst);}voidvmovq_mr_disp32(int32_toffset,RegisterIDbase,XMMRegisterIDdst){twoByteOpSimd_disp32("vmovq",VEX_SS,OP2_MOVQ_VdWd,offset,base,invalid_xmm,dst);}voidvmovq_mr(int32_toffset,RegisterIDbase,RegisterIDindex,int32_tscale,XMMRegisterIDdst){twoByteOpSimd("vmovq",VEX_SS,OP2_MOVQ_VdWd,offset,base,index,scale,invalid_xmm,dst);}voidvmovq_mr(constvoid*addr,XMMRegisterIDdst){twoByteOpSimd("vmovq",VEX_SS,OP2_MOVQ_VdWd,addr,invalid_xmm,dst);}voidmovl_rm(RegisterIDsrc,constvoid*addr){if(src==rax#ifdef JS_CODEGEN_X64&&!IsAddressImmediate(addr)#endif){movl_EAXm(addr);return;}spew("movl %s, %p",GPReg32Name(src),addr);m_formatter.oneByteOp(OP_MOV_EvGv,addr,src);}voidmovl_i32m(int32_timm,constvoid*addr){spew("movl $%d, %p",imm,addr);m_formatter.oneByteOp(OP_GROUP11_EvIz,addr,GROUP11_MOV);m_formatter.immediate32(imm);}voidmovb_rm(RegisterIDsrc,int32_toffset,RegisterIDbase){spew("movb %s, "MEM_ob,GPReg8Name(src),ADDR_ob(offset,base));m_formatter.oneByteOp8(OP_MOV_EbGv,offset,base,src);}voidmovb_rm_disp32(RegisterIDsrc,int32_toffset,RegisterIDbase){spew("movb %s, "MEM_o32b,GPReg8Name(src),ADDR_o32b(offset,base));m_formatter.oneByteOp8_disp32(OP_MOV_EbGv,offset,base,src);}voidmovb_rm(RegisterIDsrc,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("movb %s, "MEM_obs,GPReg8Name(src),ADDR_obs(offset,base,index,scale));m_formatter.oneByteOp8(OP_MOV_EbGv,offset,base,index,scale,src);}voidmovb_rm(RegisterIDsrc,constvoid*addr){spew("movb %s, %p",GPReg8Name(src),addr);m_formatter.oneByteOp8(OP_MOV_EbGv,addr,src);}voidmovb_mr(int32_toffset,RegisterIDbase,RegisterIDdst){spew("movb "MEM_ob", %s",ADDR_ob(offset,base),GPReg8Name(dst));m_formatter.oneByteOp(OP_MOV_GvEb,offset,base,dst);}voidmovb_mr(int32_toffset,RegisterIDbase,RegisterIDindex,intscale,RegisterIDdst){spew("movb "MEM_obs", %s",ADDR_obs(offset,base,index,scale),GPReg8Name(dst));m_formatter.oneByteOp(OP_MOV_GvEb,offset,base,index,scale,dst);}voidmovzbl_mr(int32_toffset,RegisterIDbase,RegisterIDdst){spew("movzbl "MEM_ob", %s",ADDR_ob(offset,base),GPReg32Name(dst));m_formatter.twoByteOp(OP2_MOVZX_GvEb,offset,base,dst);}voidmovzbl_mr_disp32(int32_toffset,RegisterIDbase,RegisterIDdst){spew("movzbl "MEM_o32b", %s",ADDR_o32b(offset,base),GPReg32Name(dst));m_formatter.twoByteOp_disp32(OP2_MOVZX_GvEb,offset,base,dst);}voidmovzbl_mr(int32_toffset,RegisterIDbase,RegisterIDindex,intscale,RegisterIDdst){spew("movzbl "MEM_obs", %s",ADDR_obs(offset,base,index,scale),GPReg32Name(dst));m_formatter.twoByteOp(OP2_MOVZX_GvEb,offset,base,index,scale,dst);}voidmovzbl_mr(constvoid*addr,RegisterIDdst){spew("movzbl %p, %s",addr,GPReg32Name(dst));m_formatter.twoByteOp(OP2_MOVZX_GvEb,addr,dst);}voidmovsbl_rr(RegisterIDsrc,RegisterIDdst){spew("movsbl %s, %s",GPReg8Name(src),GPReg32Name(dst));m_formatter.twoByteOp8_movx(OP2_MOVSX_GvEb,src,dst);}voidmovsbl_mr(int32_toffset,RegisterIDbase,RegisterIDdst){spew("movsbl "MEM_ob", %s",ADDR_ob(offset,base),GPReg32Name(dst));m_formatter.twoByteOp(OP2_MOVSX_GvEb,offset,base,dst);}voidmovsbl_mr_disp32(int32_toffset,RegisterIDbase,RegisterIDdst){spew("movsbl "MEM_o32b", %s",ADDR_o32b(offset,base),GPReg32Name(dst));m_formatter.twoByteOp_disp32(OP2_MOVSX_GvEb,offset,base,dst);}voidmovsbl_mr(int32_toffset,RegisterIDbase,RegisterIDindex,intscale,RegisterIDdst){spew("movsbl "MEM_obs", %s",ADDR_obs(offset,base,index,scale),GPReg32Name(dst));m_formatter.twoByteOp(OP2_MOVSX_GvEb,offset,base,index,scale,dst);}voidmovsbl_mr(constvoid*addr,RegisterIDdst){spew("movsbl %p, %s",addr,GPReg32Name(dst));m_formatter.twoByteOp(OP2_MOVSX_GvEb,addr,dst);}voidmovzwl_rr(RegisterIDsrc,RegisterIDdst){spew("movzwl %s, %s",GPReg16Name(src),GPReg32Name(dst));m_formatter.twoByteOp(OP2_MOVZX_GvEw,src,dst);}voidmovzwl_mr(int32_toffset,RegisterIDbase,RegisterIDdst){spew("movzwl "MEM_ob", %s",ADDR_ob(offset,base),GPReg32Name(dst));m_formatter.twoByteOp(OP2_MOVZX_GvEw,offset,base,dst);}voidmovzwl_mr_disp32(int32_toffset,RegisterIDbase,RegisterIDdst){spew("movzwl "MEM_o32b", %s",ADDR_o32b(offset,base),GPReg32Name(dst));m_formatter.twoByteOp_disp32(OP2_MOVZX_GvEw,offset,base,dst);}voidmovzwl_mr(int32_toffset,RegisterIDbase,RegisterIDindex,intscale,RegisterIDdst){spew("movzwl "MEM_obs", %s",ADDR_obs(offset,base,index,scale),GPReg32Name(dst));m_formatter.twoByteOp(OP2_MOVZX_GvEw,offset,base,index,scale,dst);}voidmovzwl_mr(constvoid*addr,RegisterIDdst){spew("movzwl %p, %s",addr,GPReg32Name(dst));m_formatter.twoByteOp(OP2_MOVZX_GvEw,addr,dst);}voidmovswl_rr(RegisterIDsrc,RegisterIDdst){spew("movswl %s, %s",GPReg16Name(src),GPReg32Name(dst));m_formatter.twoByteOp(OP2_MOVSX_GvEw,src,dst);}voidmovswl_mr(int32_toffset,RegisterIDbase,RegisterIDdst){spew("movswl "MEM_ob", %s",ADDR_ob(offset,base),GPReg32Name(dst));m_formatter.twoByteOp(OP2_MOVSX_GvEw,offset,base,dst);}voidmovswl_mr_disp32(int32_toffset,RegisterIDbase,RegisterIDdst){spew("movswl "MEM_o32b", %s",ADDR_o32b(offset,base),GPReg32Name(dst));m_formatter.twoByteOp_disp32(OP2_MOVSX_GvEw,offset,base,dst);}voidmovswl_mr(int32_toffset,RegisterIDbase,RegisterIDindex,intscale,RegisterIDdst){spew("movswl "MEM_obs", %s",ADDR_obs(offset,base,index,scale),GPReg32Name(dst));m_formatter.twoByteOp(OP2_MOVSX_GvEw,offset,base,index,scale,dst);}voidmovswl_mr(constvoid*addr,RegisterIDdst){spew("movswl %p, %s",addr,GPReg32Name(dst));m_formatter.twoByteOp(OP2_MOVSX_GvEw,addr,dst);}voidmovzbl_rr(RegisterIDsrc,RegisterIDdst){spew("movzbl %s, %s",GPReg8Name(src),GPReg32Name(dst));m_formatter.twoByteOp8_movx(OP2_MOVZX_GvEb,src,dst);}voidleal_mr(int32_toffset,RegisterIDbase,RegisterIDindex,intscale,RegisterIDdst){spew("leal "MEM_obs", %s",ADDR_obs(offset,base,index,scale),GPReg32Name(dst));m_formatter.oneByteOp(OP_LEA,offset,base,index,scale,dst);}voidleal_mr(int32_toffset,RegisterIDbase,RegisterIDdst){spew("leal "MEM_ob", %s",ADDR_ob(offset,base),GPReg32Name(dst));m_formatter.oneByteOp(OP_LEA,offset,base,dst);}// Flow control:MOZ_MUST_USEJmpSrccall(){m_formatter.oneByteOp(OP_CALL_rel32);JmpSrcr=m_formatter.immediateRel32();spew("call .Lfrom%d",r.offset());returnr;}voidcall_r(RegisterIDdst){m_formatter.oneByteOp(OP_GROUP5_Ev,dst,GROUP5_OP_CALLN);spew("call *%s",GPRegName(dst));}voidcall_m(int32_toffset,RegisterIDbase){spew("call *"MEM_ob,ADDR_ob(offset,base));m_formatter.oneByteOp(OP_GROUP5_Ev,offset,base,GROUP5_OP_CALLN);}// Comparison of EAX against a 32-bit immediate. The immediate is patched// in as if it were a jump target. The intention is to toggle the first// byte of the instruction between a CMP and a JMP to produce a pseudo-NOP.MOZ_MUST_USEJmpSrccmp_eax(){m_formatter.oneByteOp(OP_CMP_EAXIv);JmpSrcr=m_formatter.immediateRel32();spew("cmpl %%eax, .Lfrom%d",r.offset());returnr;}voidjmp_i(JmpDstdst){int32_tdiff=dst.offset()-m_formatter.size();spew("jmp .Llabel%d",dst.offset());// The jump immediate is an offset from the end of the jump instruction.// A jump instruction is either 1 byte opcode and 1 byte offset, or 1// byte opcode and 4 bytes offset.if(CAN_SIGN_EXTEND_8_32(diff-2)){m_formatter.oneByteOp(OP_JMP_rel8);m_formatter.immediate8s(diff-2);}else{m_formatter.oneByteOp(OP_JMP_rel32);m_formatter.immediate32(diff-5);}}MOZ_MUST_USEJmpSrcjmp(){m_formatter.oneByteOp(OP_JMP_rel32);JmpSrcr=m_formatter.immediateRel32();spew("jmp .Lfrom%d",r.offset());returnr;}voidjmp_r(RegisterIDdst){spew("jmp *%s",GPRegName(dst));m_formatter.oneByteOp(OP_GROUP5_Ev,dst,GROUP5_OP_JMPN);}voidjmp_m(int32_toffset,RegisterIDbase){spew("jmp *"MEM_ob,ADDR_ob(offset,base));m_formatter.oneByteOp(OP_GROUP5_Ev,offset,base,GROUP5_OP_JMPN);}voidjmp_m(int32_toffset,RegisterIDbase,RegisterIDindex,intscale){spew("jmp *"MEM_obs,ADDR_obs(offset,base,index,scale));m_formatter.oneByteOp(OP_GROUP5_Ev,offset,base,index,scale,GROUP5_OP_JMPN);}voidjCC_i(Conditioncond,JmpDstdst){int32_tdiff=dst.offset()-m_formatter.size();spew("j%s .Llabel%d",CCName(cond),dst.offset());// The jump immediate is an offset from the end of the jump instruction.// A conditional jump instruction is either 1 byte opcode and 1 byte// offset, or 2 bytes opcode and 4 bytes offset.if(CAN_SIGN_EXTEND_8_32(diff-2)){m_formatter.oneByteOp(jccRel8(cond));m_formatter.immediate8s(diff-2);}else{m_formatter.twoByteOp(jccRel32(cond));m_formatter.immediate32(diff-6);}}MOZ_MUST_USEJmpSrcjCC(Conditioncond){m_formatter.twoByteOp(jccRel32(cond));JmpSrcr=m_formatter.immediateRel32();spew("j%s .Lfrom%d",CCName(cond),r.offset());returnr;}// SSE operations:voidvpcmpeqb_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpcmpeqb",VEX_PD,OP2_PCMPEQB_VdqWdq,src1,src0,dst);}voidvpcmpeqb_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpcmpeqb",VEX_PD,OP2_PCMPEQB_VdqWdq,offset,base,src0,dst);}voidvpcmpeqb_mr(constvoid*address,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpcmpeqb",VEX_PD,OP2_PCMPEQB_VdqWdq,address,src0,dst);}voidvpcmpgtb_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpcmpgtb",VEX_PD,OP2_PCMPGTB_VdqWdq,src1,src0,dst);}voidvpcmpgtb_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpcmpgtb",VEX_PD,OP2_PCMPGTB_VdqWdq,offset,base,src0,dst);}voidvpcmpgtb_mr(constvoid*address,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpcmpgtb",VEX_PD,OP2_PCMPGTB_VdqWdq,address,src0,dst);}voidvpcmpeqw_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpcmpeqw",VEX_PD,OP2_PCMPEQW_VdqWdq,src1,src0,dst);}voidvpcmpeqw_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpcmpeqw",VEX_PD,OP2_PCMPEQW_VdqWdq,offset,base,src0,dst);}voidvpcmpeqw_mr(constvoid*address,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpcmpeqw",VEX_PD,OP2_PCMPEQW_VdqWdq,address,src0,dst);}voidvpcmpgtw_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpcmpgtw",VEX_PD,OP2_PCMPGTW_VdqWdq,src1,src0,dst);}voidvpcmpgtw_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpcmpgtw",VEX_PD,OP2_PCMPGTW_VdqWdq,offset,base,src0,dst);}voidvpcmpgtw_mr(constvoid*address,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpcmpgtw",VEX_PD,OP2_PCMPGTW_VdqWdq,address,src0,dst);}voidvpcmpeqd_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpcmpeqd",VEX_PD,OP2_PCMPEQD_VdqWdq,src1,src0,dst);}voidvpcmpeqd_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpcmpeqd",VEX_PD,OP2_PCMPEQD_VdqWdq,offset,base,src0,dst);}voidvpcmpeqd_mr(constvoid*address,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpcmpeqd",VEX_PD,OP2_PCMPEQD_VdqWdq,address,src0,dst);}voidvpcmpgtd_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpcmpgtd",VEX_PD,OP2_PCMPGTD_VdqWdq,src1,src0,dst);}voidvpcmpgtd_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpcmpgtd",VEX_PD,OP2_PCMPGTD_VdqWdq,offset,base,src0,dst);}voidvpcmpgtd_mr(constvoid*address,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpcmpgtd",VEX_PD,OP2_PCMPGTD_VdqWdq,address,src0,dst);}voidvcmpps_rr(uint8_torder,XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpImmSimd("vcmpps",VEX_PS,OP2_CMPPS_VpsWps,order,src1,src0,dst);}voidvcmpps_mr(uint8_torder,int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpImmSimd("vcmpps",VEX_PS,OP2_CMPPS_VpsWps,order,offset,base,src0,dst);}voidvcmpps_mr(uint8_torder,constvoid*address,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpImmSimd("vcmpps",VEX_PS,OP2_CMPPS_VpsWps,order,address,src0,dst);}voidvrcpps_rr(XMMRegisterIDsrc,XMMRegisterIDdst){twoByteOpSimd("vrcpps",VEX_PS,OP2_RCPPS_VpsWps,src,invalid_xmm,dst);}voidvrcpps_mr(int32_toffset,RegisterIDbase,XMMRegisterIDdst){twoByteOpSimd("vrcpps",VEX_PS,OP2_RCPPS_VpsWps,offset,base,invalid_xmm,dst);}voidvrcpps_mr(constvoid*address,XMMRegisterIDdst){twoByteOpSimd("vrcpps",VEX_PS,OP2_RCPPS_VpsWps,address,invalid_xmm,dst);}voidvrsqrtps_rr(XMMRegisterIDsrc,XMMRegisterIDdst){twoByteOpSimd("vrsqrtps",VEX_PS,OP2_RSQRTPS_VpsWps,src,invalid_xmm,dst);}voidvrsqrtps_mr(int32_toffset,RegisterIDbase,XMMRegisterIDdst){twoByteOpSimd("vrsqrtps",VEX_PS,OP2_RSQRTPS_VpsWps,offset,base,invalid_xmm,dst);}voidvrsqrtps_mr(constvoid*address,XMMRegisterIDdst){twoByteOpSimd("vrsqrtps",VEX_PS,OP2_RSQRTPS_VpsWps,address,invalid_xmm,dst);}voidvsqrtps_rr(XMMRegisterIDsrc,XMMRegisterIDdst){twoByteOpSimd("vsqrtps",VEX_PS,OP2_SQRTPS_VpsWps,src,invalid_xmm,dst);}voidvsqrtps_mr(int32_toffset,RegisterIDbase,XMMRegisterIDdst){twoByteOpSimd("vsqrtps",VEX_PS,OP2_SQRTPS_VpsWps,offset,base,invalid_xmm,dst);}voidvsqrtps_mr(constvoid*address,XMMRegisterIDdst){twoByteOpSimd("vsqrtps",VEX_PS,OP2_SQRTPS_VpsWps,address,invalid_xmm,dst);}voidvaddsd_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vaddsd",VEX_SD,OP2_ADDSD_VsdWsd,src1,src0,dst);}voidvaddss_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vaddss",VEX_SS,OP2_ADDSD_VsdWsd,src1,src0,dst);}voidvaddsd_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vaddsd",VEX_SD,OP2_ADDSD_VsdWsd,offset,base,src0,dst);}voidvaddss_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vaddss",VEX_SS,OP2_ADDSD_VsdWsd,offset,base,src0,dst);}voidvaddsd_mr(constvoid*address,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vaddsd",VEX_SD,OP2_ADDSD_VsdWsd,address,src0,dst);}voidvaddss_mr(constvoid*address,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vaddss",VEX_SS,OP2_ADDSD_VsdWsd,address,src0,dst);}voidvcvtss2sd_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vcvtss2sd",VEX_SS,OP2_CVTSS2SD_VsdEd,src1,src0,dst);}voidvcvtsd2ss_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vcvtsd2ss",VEX_SD,OP2_CVTSD2SS_VsdEd,src1,src0,dst);}voidvcvtsi2ss_rr(RegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpInt32Simd("vcvtsi2ss",VEX_SS,OP2_CVTSI2SD_VsdEd,src1,src0,dst);}voidvcvtsi2sd_rr(RegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpInt32Simd("vcvtsi2sd",VEX_SD,OP2_CVTSI2SD_VsdEd,src1,src0,dst);}voidvcvttps2dq_rr(XMMRegisterIDsrc,XMMRegisterIDdst){twoByteOpSimd("vcvttps2dq",VEX_SS,OP2_CVTTPS2DQ_VdqWps,src,invalid_xmm,dst);}voidvcvtdq2ps_rr(XMMRegisterIDsrc,XMMRegisterIDdst){twoByteOpSimd("vcvtdq2ps",VEX_PS,OP2_CVTDQ2PS_VpsWdq,src,invalid_xmm,dst);}voidvcvtsi2sd_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vcvtsi2sd",VEX_SD,OP2_CVTSI2SD_VsdEd,offset,base,src0,dst);}voidvcvtsi2sd_mr(int32_toffset,RegisterIDbase,RegisterIDindex,intscale,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vcvtsi2sd",VEX_SD,OP2_CVTSI2SD_VsdEd,offset,base,index,scale,src0,dst);}voidvcvtsi2ss_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vcvtsi2ss",VEX_SS,OP2_CVTSI2SD_VsdEd,offset,base,src0,dst);}voidvcvtsi2ss_mr(int32_toffset,RegisterIDbase,RegisterIDindex,intscale,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vcvtsi2ss",VEX_SS,OP2_CVTSI2SD_VsdEd,offset,base,index,scale,src0,dst);}voidvcvttsd2si_rr(XMMRegisterIDsrc,RegisterIDdst){twoByteOpSimdInt32("vcvttsd2si",VEX_SD,OP2_CVTTSD2SI_GdWsd,src,dst);}voidvcvttss2si_rr(XMMRegisterIDsrc,RegisterIDdst){twoByteOpSimdInt32("vcvttss2si",VEX_SS,OP2_CVTTSD2SI_GdWsd,src,dst);}voidvunpcklps_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vunpcklps",VEX_PS,OP2_UNPCKLPS_VsdWsd,src1,src0,dst);}voidvunpcklps_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vunpcklps",VEX_PS,OP2_UNPCKLPS_VsdWsd,offset,base,src0,dst);}voidvunpcklps_mr(constvoid*addr,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vunpcklps",VEX_PS,OP2_UNPCKLPS_VsdWsd,addr,src0,dst);}voidvunpckhps_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vunpckhps",VEX_PS,OP2_UNPCKHPS_VsdWsd,src1,src0,dst);}voidvunpckhps_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vunpckhps",VEX_PS,OP2_UNPCKHPS_VsdWsd,offset,base,src0,dst);}voidvunpckhps_mr(constvoid*addr,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vunpckhps",VEX_PS,OP2_UNPCKHPS_VsdWsd,addr,src0,dst);}voidvpand_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpand",VEX_PD,OP2_PANDDQ_VdqWdq,src1,src0,dst);}voidvpand_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpand",VEX_PD,OP2_PANDDQ_VdqWdq,offset,base,src0,dst);}voidvpand_mr(constvoid*address,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpand",VEX_PD,OP2_PANDDQ_VdqWdq,address,src0,dst);}voidvpor_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpor",VEX_PD,OP2_PORDQ_VdqWdq,src1,src0,dst);}voidvpor_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpor",VEX_PD,OP2_PORDQ_VdqWdq,offset,base,src0,dst);}voidvpor_mr(constvoid*address,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpor",VEX_PD,OP2_PORDQ_VdqWdq,address,src0,dst);}voidvpxor_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpxor",VEX_PD,OP2_PXORDQ_VdqWdq,src1,src0,dst);}voidvpxor_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpxor",VEX_PD,OP2_PXORDQ_VdqWdq,offset,base,src0,dst);}voidvpxor_mr(constvoid*address,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpxor",VEX_PD,OP2_PXORDQ_VdqWdq,address,src0,dst);}voidvpandn_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpandn",VEX_PD,OP2_PANDNDQ_VdqWdq,src1,src0,dst);}voidvpandn_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpandn",VEX_PD,OP2_PANDNDQ_VdqWdq,offset,base,src0,dst);}voidvpandn_mr(constvoid*address,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpandn",VEX_PD,OP2_PANDNDQ_VdqWdq,address,src0,dst);}voidvpshufd_irr(uint32_tmask,XMMRegisterIDsrc,XMMRegisterIDdst){twoByteOpImmSimd("vpshufd",VEX_PD,OP2_PSHUFD_VdqWdqIb,mask,src,invalid_xmm,dst);}voidvpshufd_imr(uint32_tmask,int32_toffset,RegisterIDbase,XMMRegisterIDdst){twoByteOpImmSimd("vpshufd",VEX_PD,OP2_PSHUFD_VdqWdqIb,mask,offset,base,invalid_xmm,dst);}voidvpshufd_imr(uint32_tmask,constvoid*address,XMMRegisterIDdst){twoByteOpImmSimd("vpshufd",VEX_PD,OP2_PSHUFD_VdqWdqIb,mask,address,invalid_xmm,dst);}voidvpshuflw_irr(uint32_tmask,XMMRegisterIDsrc,XMMRegisterIDdst){twoByteOpImmSimd("vpshuflw",VEX_SD,OP2_PSHUFLW_VdqWdqIb,mask,src,invalid_xmm,dst);}voidvpshufhw_irr(uint32_tmask,XMMRegisterIDsrc,XMMRegisterIDdst){twoByteOpImmSimd("vpshufhw",VEX_SS,OP2_PSHUFHW_VdqWdqIb,mask,src,invalid_xmm,dst);}voidvpshufb_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){threeByteOpSimd("vpshufb",VEX_PD,OP3_PSHUFB_VdqWdq,ESCAPE_38,src1,src0,dst);}voidvshufps_irr(uint32_tmask,XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpImmSimd("vshufps",VEX_PS,OP2_SHUFPS_VpsWpsIb,mask,src1,src0,dst);}voidvshufps_imr(uint32_tmask,int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpImmSimd("vshufps",VEX_PS,OP2_SHUFPS_VpsWpsIb,mask,offset,base,src0,dst);}voidvshufps_imr(uint32_tmask,constvoid*address,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpImmSimd("vshufps",VEX_PS,OP2_SHUFPS_VpsWpsIb,mask,address,src0,dst);}voidvmovddup_rr(XMMRegisterIDsrc,XMMRegisterIDdst){twoByteOpSimd("vmovddup",VEX_SD,OP2_MOVDDUP_VqWq,src,invalid_xmm,dst);}voidvmovhlps_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vmovhlps",VEX_PS,OP2_MOVHLPS_VqUq,src1,src0,dst);}voidvmovlhps_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vmovlhps",VEX_PS,OP2_MOVLHPS_VqUq,src1,src0,dst);}voidvpsrldq_ir(uint32_tcount,XMMRegisterIDsrc,XMMRegisterIDdst){MOZ_ASSERT(count<16);shiftOpImmSimd("vpsrldq",OP2_PSRLDQ_Vd,ShiftID::vpsrldq,count,src,dst);}voidvpsllq_ir(uint32_tcount,XMMRegisterIDsrc,XMMRegisterIDdst){MOZ_ASSERT(count<64);shiftOpImmSimd("vpsllq",OP2_PSRLDQ_Vd,ShiftID::vpsllx,count,src,dst);}voidvpsrlq_ir(uint32_tcount,XMMRegisterIDsrc,XMMRegisterIDdst){MOZ_ASSERT(count<64);shiftOpImmSimd("vpsrlq",OP2_PSRLDQ_Vd,ShiftID::vpsrlx,count,src,dst);}voidvpslld_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpslld",VEX_PD,OP2_PSLLD_VdqWdq,src1,src0,dst);}voidvpslld_ir(uint32_tcount,XMMRegisterIDsrc,XMMRegisterIDdst){MOZ_ASSERT(count<32);shiftOpImmSimd("vpslld",OP2_PSLLD_UdqIb,ShiftID::vpsllx,count,src,dst);}voidvpsrad_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpsrad",VEX_PD,OP2_PSRAD_VdqWdq,src1,src0,dst);}voidvpsrad_ir(int32_tcount,XMMRegisterIDsrc,XMMRegisterIDdst){MOZ_ASSERT(count<32);shiftOpImmSimd("vpsrad",OP2_PSRAD_UdqIb,ShiftID::vpsrad,count,src,dst);}voidvpsrld_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpsrld",VEX_PD,OP2_PSRLD_VdqWdq,src1,src0,dst);}voidvpsrld_ir(uint32_tcount,XMMRegisterIDsrc,XMMRegisterIDdst){MOZ_ASSERT(count<32);shiftOpImmSimd("vpsrld",OP2_PSRLD_UdqIb,ShiftID::vpsrlx,count,src,dst);}voidvpsllw_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpsllw",VEX_PD,OP2_PSLLW_VdqWdq,src1,src0,dst);}voidvpsllw_ir(uint32_tcount,XMMRegisterIDsrc,XMMRegisterIDdst){MOZ_ASSERT(count<16);shiftOpImmSimd("vpsllw",OP2_PSLLW_UdqIb,ShiftID::vpsllx,count,src,dst);}voidvpsraw_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpsraw",VEX_PD,OP2_PSRAW_VdqWdq,src1,src0,dst);}voidvpsraw_ir(int32_tcount,XMMRegisterIDsrc,XMMRegisterIDdst){MOZ_ASSERT(count<16);shiftOpImmSimd("vpsraw",OP2_PSRAW_UdqIb,ShiftID::vpsrad,count,src,dst);}voidvpsrlw_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vpsrlw",VEX_PD,OP2_PSRLW_VdqWdq,src1,src0,dst);}voidvpsrlw_ir(uint32_tcount,XMMRegisterIDsrc,XMMRegisterIDdst){MOZ_ASSERT(count<16);shiftOpImmSimd("vpsrlw",OP2_PSRLW_UdqIb,ShiftID::vpsrlx,count,src,dst);}voidvmovmskpd_rr(XMMRegisterIDsrc,RegisterIDdst){twoByteOpSimdInt32("vmovmskpd",VEX_PD,OP2_MOVMSKPD_EdVd,src,dst);}voidvmovmskps_rr(XMMRegisterIDsrc,RegisterIDdst){twoByteOpSimdInt32("vmovmskps",VEX_PS,OP2_MOVMSKPD_EdVd,src,dst);}voidvpmovmskb_rr(XMMRegisterIDsrc,RegisterIDdst){twoByteOpSimdInt32("vpmovmskb",VEX_PD,OP2_PMOVMSKB_EdVd,src,dst);}voidvptest_rr(XMMRegisterIDrhs,XMMRegisterIDlhs){threeByteOpSimd("vptest",VEX_PD,OP3_PTEST_VdVd,ESCAPE_38,rhs,invalid_xmm,lhs);}voidvmovd_rr(XMMRegisterIDsrc,RegisterIDdst){twoByteOpSimdInt32("vmovd",VEX_PD,OP2_MOVD_EdVd,(XMMRegisterID)dst,(RegisterID)src);}voidvmovd_rr(RegisterIDsrc,XMMRegisterIDdst){twoByteOpInt32Simd("vmovd",VEX_PD,OP2_MOVD_VdEd,src,invalid_xmm,dst);}voidvmovd_mr(int32_toffset,RegisterIDbase,XMMRegisterIDdst){twoByteOpSimd("vmovd",VEX_PD,OP2_MOVD_VdEd,offset,base,invalid_xmm,dst);}voidvmovd_mr(int32_toffset,RegisterIDbase,RegisterIDindex,int32_tscale,XMMRegisterIDdst){twoByteOpSimd("vmovd",VEX_PD,OP2_MOVD_VdEd,offset,base,index,scale,invalid_xmm,dst);}voidvmovd_mr_disp32(int32_toffset,RegisterIDbase,XMMRegisterIDdst){twoByteOpSimd_disp32("vmovd",VEX_PD,OP2_MOVD_VdEd,offset,base,invalid_xmm,dst);}voidvmovd_mr(constvoid*address,XMMRegisterIDdst){twoByteOpSimd("vmovd",VEX_PD,OP2_MOVD_VdEd,address,invalid_xmm,dst);}voidvmovd_rm(XMMRegisterIDsrc,int32_toffset,RegisterIDbase){twoByteOpSimd("vmovd",VEX_PD,OP2_MOVD_EdVd,offset,base,invalid_xmm,src);}voidvmovd_rm(XMMRegisterIDsrc,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){twoByteOpSimd("vmovd",VEX_PD,OP2_MOVD_EdVd,offset,base,index,scale,invalid_xmm,src);}voidvmovd_rm_disp32(XMMRegisterIDsrc,int32_toffset,RegisterIDbase){twoByteOpSimd_disp32("vmovd",VEX_PD,OP2_MOVD_EdVd,offset,base,invalid_xmm,src);}voidvmovd_rm(XMMRegisterIDsrc,constvoid*address){twoByteOpSimd("vmovd",VEX_PD,OP2_MOVD_EdVd,address,invalid_xmm,src);}voidvmovsd_rm(XMMRegisterIDsrc,int32_toffset,RegisterIDbase){twoByteOpSimd("vmovsd",VEX_SD,OP2_MOVSD_WsdVsd,offset,base,invalid_xmm,src);}voidvmovsd_rm_disp32(XMMRegisterIDsrc,int32_toffset,RegisterIDbase){twoByteOpSimd_disp32("vmovsd",VEX_SD,OP2_MOVSD_WsdVsd,offset,base,invalid_xmm,src);}voidvmovss_rm(XMMRegisterIDsrc,int32_toffset,RegisterIDbase){twoByteOpSimd("vmovss",VEX_SS,OP2_MOVSD_WsdVsd,offset,base,invalid_xmm,src);}voidvmovss_rm_disp32(XMMRegisterIDsrc,int32_toffset,RegisterIDbase){twoByteOpSimd_disp32("vmovss",VEX_SS,OP2_MOVSD_WsdVsd,offset,base,invalid_xmm,src);}voidvmovss_mr(int32_toffset,RegisterIDbase,XMMRegisterIDdst){twoByteOpSimd("vmovss",VEX_SS,OP2_MOVSD_VsdWsd,offset,base,invalid_xmm,dst);}voidvmovss_mr_disp32(int32_toffset,RegisterIDbase,XMMRegisterIDdst){twoByteOpSimd_disp32("vmovss",VEX_SS,OP2_MOVSD_VsdWsd,offset,base,invalid_xmm,dst);}voidvmovsd_rm(XMMRegisterIDsrc,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){twoByteOpSimd("vmovsd",VEX_SD,OP2_MOVSD_WsdVsd,offset,base,index,scale,invalid_xmm,src);}voidvmovss_rm(XMMRegisterIDsrc,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){twoByteOpSimd("vmovss",VEX_SS,OP2_MOVSD_WsdVsd,offset,base,index,scale,invalid_xmm,src);}voidvmovss_mr(int32_toffset,RegisterIDbase,RegisterIDindex,intscale,XMMRegisterIDdst){twoByteOpSimd("vmovss",VEX_SS,OP2_MOVSD_VsdWsd,offset,base,index,scale,invalid_xmm,dst);}voidvmovsd_mr(int32_toffset,RegisterIDbase,XMMRegisterIDdst){twoByteOpSimd("vmovsd",VEX_SD,OP2_MOVSD_VsdWsd,offset,base,invalid_xmm,dst);}voidvmovsd_mr_disp32(int32_toffset,RegisterIDbase,XMMRegisterIDdst){twoByteOpSimd_disp32("vmovsd",VEX_SD,OP2_MOVSD_VsdWsd,offset,base,invalid_xmm,dst);}voidvmovsd_mr(int32_toffset,RegisterIDbase,RegisterIDindex,intscale,XMMRegisterIDdst){twoByteOpSimd("vmovsd",VEX_SD,OP2_MOVSD_VsdWsd,offset,base,index,scale,invalid_xmm,dst);}// Note that the register-to-register form of vmovsd does not write to the// entire output register. For general-purpose register-to-register moves,// use vmovapd instead.voidvmovsd_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vmovsd",VEX_SD,OP2_MOVSD_VsdWsd,src1,src0,dst);}// The register-to-register form of vmovss has the same problem as vmovsd// above. Prefer vmovaps for register-to-register moves.voidvmovss_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vmovss",VEX_SS,OP2_MOVSD_VsdWsd,src1,src0,dst);}voidvmovsd_mr(constvoid*address,XMMRegisterIDdst){twoByteOpSimd("vmovsd",VEX_SD,OP2_MOVSD_VsdWsd,address,invalid_xmm,dst);}voidvmovss_mr(constvoid*address,XMMRegisterIDdst){twoByteOpSimd("vmovss",VEX_SS,OP2_MOVSD_VsdWsd,address,invalid_xmm,dst);}voidvmovups_mr(constvoid*address,XMMRegisterIDdst){twoByteOpSimd("vmovups",VEX_PS,OP2_MOVPS_VpsWps,address,invalid_xmm,dst);}voidvmovdqu_mr(constvoid*address,XMMRegisterIDdst){twoByteOpSimd("vmovdqu",VEX_SS,OP2_MOVDQ_VdqWdq,address,invalid_xmm,dst);}voidvmovsd_rm(XMMRegisterIDsrc,constvoid*address){twoByteOpSimd("vmovsd",VEX_SD,OP2_MOVSD_WsdVsd,address,invalid_xmm,src);}voidvmovss_rm(XMMRegisterIDsrc,constvoid*address){twoByteOpSimd("vmovss",VEX_SS,OP2_MOVSD_WsdVsd,address,invalid_xmm,src);}voidvmovdqa_rm(XMMRegisterIDsrc,constvoid*address){twoByteOpSimd("vmovdqa",VEX_PD,OP2_MOVDQ_WdqVdq,address,invalid_xmm,src);}voidvmovaps_rm(XMMRegisterIDsrc,constvoid*address){twoByteOpSimd("vmovaps",VEX_PS,OP2_MOVAPS_WsdVsd,address,invalid_xmm,src);}voidvmovdqu_rm(XMMRegisterIDsrc,constvoid*address){twoByteOpSimd("vmovdqu",VEX_SS,OP2_MOVDQ_WdqVdq,address,invalid_xmm,src);}voidvmovups_rm(XMMRegisterIDsrc,constvoid*address){twoByteOpSimd("vmovups",VEX_PS,OP2_MOVPS_WpsVps,address,invalid_xmm,src);}voidvmovaps_rr(XMMRegisterIDsrc,XMMRegisterIDdst){#ifdef JS_CODEGEN_X64// There are two opcodes that can encode this instruction. If we have// one register in [xmm8,xmm15] and one in [xmm0,xmm7], use the// opcode which swaps the operands, as that way we can get a two-byte// VEX in that case.if(src>=xmm8&&dst<xmm8){twoByteOpSimd("vmovaps",VEX_PS,OP2_MOVAPS_WsdVsd,dst,invalid_xmm,src);return;}#endiftwoByteOpSimd("vmovaps",VEX_PS,OP2_MOVAPS_VsdWsd,src,invalid_xmm,dst);}voidvmovaps_rm(XMMRegisterIDsrc,int32_toffset,RegisterIDbase){twoByteOpSimd("vmovaps",VEX_PS,OP2_MOVAPS_WsdVsd,offset,base,invalid_xmm,src);}voidvmovaps_rm(XMMRegisterIDsrc,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){twoByteOpSimd("vmovaps",VEX_PS,OP2_MOVAPS_WsdVsd,offset,base,index,scale,invalid_xmm,src);}voidvmovaps_mr(int32_toffset,RegisterIDbase,XMMRegisterIDdst){twoByteOpSimd("vmovaps",VEX_PS,OP2_MOVAPS_VsdWsd,offset,base,invalid_xmm,dst);}voidvmovaps_mr(int32_toffset,RegisterIDbase,RegisterIDindex,intscale,XMMRegisterIDdst){twoByteOpSimd("vmovaps",VEX_PS,OP2_MOVAPS_VsdWsd,offset,base,index,scale,invalid_xmm,dst);}voidvmovups_rm(XMMRegisterIDsrc,int32_toffset,RegisterIDbase){twoByteOpSimd("vmovups",VEX_PS,OP2_MOVPS_WpsVps,offset,base,invalid_xmm,src);}voidvmovups_rm_disp32(XMMRegisterIDsrc,int32_toffset,RegisterIDbase){twoByteOpSimd_disp32("vmovups",VEX_PS,OP2_MOVPS_WpsVps,offset,base,invalid_xmm,src);}voidvmovups_rm(XMMRegisterIDsrc,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){twoByteOpSimd("vmovups",VEX_PS,OP2_MOVPS_WpsVps,offset,base,index,scale,invalid_xmm,src);}voidvmovups_mr(int32_toffset,RegisterIDbase,XMMRegisterIDdst){twoByteOpSimd("vmovups",VEX_PS,OP2_MOVPS_VpsWps,offset,base,invalid_xmm,dst);}voidvmovups_mr_disp32(int32_toffset,RegisterIDbase,XMMRegisterIDdst){twoByteOpSimd_disp32("vmovups",VEX_PS,OP2_MOVPS_VpsWps,offset,base,invalid_xmm,dst);}voidvmovups_mr(int32_toffset,RegisterIDbase,RegisterIDindex,intscale,XMMRegisterIDdst){twoByteOpSimd("vmovups",VEX_PS,OP2_MOVPS_VpsWps,offset,base,index,scale,invalid_xmm,dst);}voidvmovapd_rr(XMMRegisterIDsrc,XMMRegisterIDdst){#ifdef JS_CODEGEN_X64// There are two opcodes that can encode this instruction. If we have// one register in [xmm8,xmm15] and one in [xmm0,xmm7], use the// opcode which swaps the operands, as that way we can get a two-byte// VEX in that case.if(src>=xmm8&&dst<xmm8){twoByteOpSimd("vmovapd",VEX_PD,OP2_MOVAPS_WsdVsd,dst,invalid_xmm,src);return;}#endiftwoByteOpSimd("vmovapd",VEX_PD,OP2_MOVAPD_VsdWsd,src,invalid_xmm,dst);}voidvmovdqu_rm(XMMRegisterIDsrc,int32_toffset,RegisterIDbase){twoByteOpSimd("vmovdqu",VEX_SS,OP2_MOVDQ_WdqVdq,offset,base,invalid_xmm,src);}voidvmovdqu_rm_disp32(XMMRegisterIDsrc,int32_toffset,RegisterIDbase){twoByteOpSimd_disp32("vmovdqu",VEX_SS,OP2_MOVDQ_WdqVdq,offset,base,invalid_xmm,src);}voidvmovdqu_rm(XMMRegisterIDsrc,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){twoByteOpSimd("vmovdqu",VEX_SS,OP2_MOVDQ_WdqVdq,offset,base,index,scale,invalid_xmm,src);}voidvmovdqu_mr(int32_toffset,RegisterIDbase,XMMRegisterIDdst){twoByteOpSimd("vmovdqu",VEX_SS,OP2_MOVDQ_VdqWdq,offset,base,invalid_xmm,dst);}voidvmovdqu_mr_disp32(int32_toffset,RegisterIDbase,XMMRegisterIDdst){twoByteOpSimd_disp32("vmovdqu",VEX_SS,OP2_MOVDQ_VdqWdq,offset,base,invalid_xmm,dst);}voidvmovdqu_mr(int32_toffset,RegisterIDbase,RegisterIDindex,intscale,XMMRegisterIDdst){twoByteOpSimd("vmovdqu",VEX_SS,OP2_MOVDQ_VdqWdq,offset,base,index,scale,invalid_xmm,dst);}voidvmovdqa_rr(XMMRegisterIDsrc,XMMRegisterIDdst){#ifdef JS_CODEGEN_X64// There are two opcodes that can encode this instruction. If we have// one register in [xmm8,xmm15] and one in [xmm0,xmm7], use the// opcode which swaps the operands, as that way we can get a two-byte// VEX in that case.if(src>=xmm8&&dst<xmm8){twoByteOpSimd("vmovdqa",VEX_PD,OP2_MOVDQ_WdqVdq,dst,invalid_xmm,src);return;}#endiftwoByteOpSimd("vmovdqa",VEX_PD,OP2_MOVDQ_VdqWdq,src,invalid_xmm,dst);}voidvmovdqa_rm(XMMRegisterIDsrc,int32_toffset,RegisterIDbase){twoByteOpSimd("vmovdqa",VEX_PD,OP2_MOVDQ_WdqVdq,offset,base,invalid_xmm,src);}voidvmovdqa_rm(XMMRegisterIDsrc,int32_toffset,RegisterIDbase,RegisterIDindex,intscale){twoByteOpSimd("vmovdqa",VEX_PD,OP2_MOVDQ_WdqVdq,offset,base,index,scale,invalid_xmm,src);}voidvmovdqa_mr(int32_toffset,RegisterIDbase,XMMRegisterIDdst){twoByteOpSimd("vmovdqa",VEX_PD,OP2_MOVDQ_VdqWdq,offset,base,invalid_xmm,dst);}voidvmovdqa_mr(int32_toffset,RegisterIDbase,RegisterIDindex,intscale,XMMRegisterIDdst){twoByteOpSimd("vmovdqa",VEX_PD,OP2_MOVDQ_VdqWdq,offset,base,index,scale,invalid_xmm,dst);}voidvmulsd_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vmulsd",VEX_SD,OP2_MULSD_VsdWsd,src1,src0,dst);}voidvmulss_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vmulss",VEX_SS,OP2_MULSD_VsdWsd,src1,src0,dst);}voidvmulsd_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vmulsd",VEX_SD,OP2_MULSD_VsdWsd,offset,base,src0,dst);}voidvmulss_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vmulss",VEX_SS,OP2_MULSD_VsdWsd,offset,base,src0,dst);}voidvpinsrw_irr(uint32_twhichWord,RegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){MOZ_ASSERT(whichWord<8);twoByteOpImmInt32Simd("vpinsrw",VEX_PD,OP2_PINSRW,whichWord,src1,src0,dst);}voidvpextrw_irr(uint32_twhichWord,XMMRegisterIDsrc,RegisterIDdst){MOZ_ASSERT(whichWord<8);twoByteOpImmSimdInt32("vpextrw",VEX_PD,OP2_PEXTRW_GdUdIb,whichWord,src,dst);}voidvsubsd_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vsubsd",VEX_SD,OP2_SUBSD_VsdWsd,src1,src0,dst);}voidvsubss_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vsubss",VEX_SS,OP2_SUBSD_VsdWsd,src1,src0,dst);}voidvsubsd_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vsubsd",VEX_SD,OP2_SUBSD_VsdWsd,offset,base,src0,dst);}voidvsubss_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vsubss",VEX_SS,OP2_SUBSD_VsdWsd,offset,base,src0,dst);}voidvucomiss_rr(XMMRegisterIDrhs,XMMRegisterIDlhs){twoByteOpSimdFlags("vucomiss",VEX_PS,OP2_UCOMISD_VsdWsd,rhs,lhs);}voidvucomisd_rr(XMMRegisterIDrhs,XMMRegisterIDlhs){twoByteOpSimdFlags("vucomisd",VEX_PD,OP2_UCOMISD_VsdWsd,rhs,lhs);}voidvucomisd_mr(int32_toffset,RegisterIDbase,XMMRegisterIDlhs){twoByteOpSimdFlags("vucomisd",VEX_PD,OP2_UCOMISD_VsdWsd,offset,base,lhs);}voidvdivsd_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vdivsd",VEX_SD,OP2_DIVSD_VsdWsd,src1,src0,dst);}voidvdivss_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vdivss",VEX_SS,OP2_DIVSD_VsdWsd,src1,src0,dst);}voidvdivsd_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vdivsd",VEX_SD,OP2_DIVSD_VsdWsd,offset,base,src0,dst);}voidvdivss_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vdivss",VEX_SS,OP2_DIVSD_VsdWsd,offset,base,src0,dst);}voidvxorpd_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vxorpd",VEX_PD,OP2_XORPD_VpdWpd,src1,src0,dst);}voidvorpd_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vorpd",VEX_PD,OP2_ORPD_VpdWpd,src1,src0,dst);}voidvandpd_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vandpd",VEX_PD,OP2_ANDPD_VpdWpd,src1,src0,dst);}voidvandps_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vandps",VEX_PS,OP2_ANDPS_VpsWps,src1,src0,dst);}voidvandps_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vandps",VEX_PS,OP2_ANDPS_VpsWps,offset,base,src0,dst);}voidvandps_mr(constvoid*address,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vandps",VEX_PS,OP2_ANDPS_VpsWps,address,src0,dst);}voidvandnps_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vandnps",VEX_PS,OP2_ANDNPS_VpsWps,src1,src0,dst);}voidvandnps_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vandnps",VEX_PS,OP2_ANDNPS_VpsWps,offset,base,src0,dst);}voidvandnps_mr(constvoid*address,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vandnps",VEX_PS,OP2_ANDNPS_VpsWps,address,src0,dst);}voidvorps_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vorps",VEX_PS,OP2_ORPS_VpsWps,src1,src0,dst);}voidvorps_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vorps",VEX_PS,OP2_ORPS_VpsWps,offset,base,src0,dst);}voidvorps_mr(constvoid*address,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vorps",VEX_PS,OP2_ORPS_VpsWps,address,src0,dst);}voidvxorps_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vxorps",VEX_PS,OP2_XORPS_VpsWps,src1,src0,dst);}voidvxorps_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vxorps",VEX_PS,OP2_XORPS_VpsWps,offset,base,src0,dst);}voidvxorps_mr(constvoid*address,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vxorps",VEX_PS,OP2_XORPS_VpsWps,address,src0,dst);}voidvsqrtsd_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vsqrtsd",VEX_SD,OP2_SQRTSD_VsdWsd,src1,src0,dst);}voidvsqrtss_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vsqrtss",VEX_SS,OP2_SQRTSS_VssWss,src1,src0,dst);}voidvroundsd_irr(RoundingModemode,XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){threeByteOpImmSimd("vroundsd",VEX_PD,OP3_ROUNDSD_VsdWsd,ESCAPE_3A,mode,src1,src0,dst);}voidvroundss_irr(RoundingModemode,XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){threeByteOpImmSimd("vroundss",VEX_PD,OP3_ROUNDSS_VsdWsd,ESCAPE_3A,mode,src1,src0,dst);}voidvinsertps_irr(uint32_tmask,XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){threeByteOpImmSimd("vinsertps",VEX_PD,OP3_INSERTPS_VpsUps,ESCAPE_3A,mask,src1,src0,dst);}voidvinsertps_imr(uint32_tmask,int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){threeByteOpImmSimd("vinsertps",VEX_PD,OP3_INSERTPS_VpsUps,ESCAPE_3A,mask,offset,base,src0,dst);}voidvpinsrb_irr(unsignedlane,RegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){MOZ_ASSERT(lane<16);threeByteOpImmInt32Simd("vpinsrb",VEX_PD,OP3_PINSRB_VdqEdIb,ESCAPE_3A,lane,src1,src0,dst);}voidvpinsrd_irr(unsignedlane,RegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){MOZ_ASSERT(lane<4);threeByteOpImmInt32Simd("vpinsrd",VEX_PD,OP3_PINSRD_VdqEdIb,ESCAPE_3A,lane,src1,src0,dst);}voidvpextrb_irr(unsignedlane,XMMRegisterIDsrc,RegisterIDdst){MOZ_ASSERT(lane<16);threeByteOpImmSimdInt32("vpextrb",VEX_PD,OP3_PEXTRB_EdVdqIb,ESCAPE_3A,lane,(XMMRegisterID)dst,(RegisterID)src);}voidvpextrd_irr(unsignedlane,XMMRegisterIDsrc,RegisterIDdst){MOZ_ASSERT(lane<4);threeByteOpImmSimdInt32("vpextrd",VEX_PD,OP3_PEXTRD_EdVdqIb,ESCAPE_3A,lane,(XMMRegisterID)dst,(RegisterID)src);}voidvblendps_irr(unsignedimm,XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){MOZ_ASSERT(imm<16);// Despite being a "ps" instruction, vblendps is encoded with the "pd" prefix.threeByteOpImmSimd("vblendps",VEX_PD,OP3_BLENDPS_VpsWpsIb,ESCAPE_3A,imm,src1,src0,dst);}voidvblendps_imr(unsignedimm,int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){MOZ_ASSERT(imm<16);// Despite being a "ps" instruction, vblendps is encoded with the "pd" prefix.threeByteOpImmSimd("vblendps",VEX_PD,OP3_BLENDPS_VpsWpsIb,ESCAPE_3A,imm,offset,base,src0,dst);}voidvblendvps_rr(XMMRegisterIDmask,XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){vblendvOpSimd(mask,src1,src0,dst);}voidvblendvps_mr(XMMRegisterIDmask,int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){vblendvOpSimd(mask,offset,base,src0,dst);}voidvmovsldup_rr(XMMRegisterIDsrc,XMMRegisterIDdst){twoByteOpSimd("vmovsldup",VEX_SS,OP2_MOVSLDUP_VpsWps,src,invalid_xmm,dst);}voidvmovsldup_mr(int32_toffset,RegisterIDbase,XMMRegisterIDdst){twoByteOpSimd("vmovsldup",VEX_SS,OP2_MOVSLDUP_VpsWps,offset,base,invalid_xmm,dst);}voidvmovshdup_rr(XMMRegisterIDsrc,XMMRegisterIDdst){twoByteOpSimd("vmovshdup",VEX_SS,OP2_MOVSHDUP_VpsWps,src,invalid_xmm,dst);}voidvmovshdup_mr(int32_toffset,RegisterIDbase,XMMRegisterIDdst){twoByteOpSimd("vmovshdup",VEX_SS,OP2_MOVSHDUP_VpsWps,offset,base,invalid_xmm,dst);}voidvminsd_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vminsd",VEX_SD,OP2_MINSD_VsdWsd,src1,src0,dst);}voidvminsd_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vminsd",VEX_SD,OP2_MINSD_VsdWsd,offset,base,src0,dst);}voidvminss_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vminss",VEX_SS,OP2_MINSS_VssWss,src1,src0,dst);}voidvmaxsd_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vmaxsd",VEX_SD,OP2_MAXSD_VsdWsd,src1,src0,dst);}voidvmaxsd_mr(int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vmaxsd",VEX_SD,OP2_MAXSD_VsdWsd,offset,base,src0,dst);}voidvmaxss_rr(XMMRegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){twoByteOpSimd("vmaxss",VEX_SS,OP2_MAXSS_VssWss,src1,src0,dst);}// Misc instructions:voidint3(){spew("int3");m_formatter.oneByteOp(OP_INT3);}voidud2(){spew("ud2");m_formatter.twoByteOp(OP2_UD2);}voidret(){spew("ret");m_formatter.oneByteOp(OP_RET);}voidret_i(int32_timm){spew("ret $%d",imm);m_formatter.oneByteOp(OP_RET_Iz);m_formatter.immediate16u(imm);}voidmfence(){spew("mfence");m_formatter.twoByteOp(OP_FENCE,(RegisterID)0,6);}// Assembler admin methods:JmpDstlabel(){JmpDstr=JmpDst(m_formatter.size());spew(".set .Llabel%d, .",r.offset());returnr;}size_tcurrentOffset()const{returnm_formatter.size();}staticJmpDstlabelFor(JmpSrcjump,intptr_toffset=0){returnJmpDst(jump.offset()+offset);}voidhaltingAlign(intalignment){spew(".balign %d, 0x%x # hlt",alignment,OP_HLT);while(!m_formatter.isAligned(alignment))m_formatter.oneByteOp(OP_HLT);}voidnopAlign(intalignment){spew(".balign %d",alignment);intremainder=m_formatter.size()%alignment;if(remainder>0)insert_nop(alignment-remainder);}voidjumpTablePointer(uintptr_tptr){#ifdef JS_CODEGEN_X64spew(".quad 0x%"PRIxPTR,ptr);#elsespew(".int 0x%"PRIxPTR,ptr);#endifm_formatter.jumpTablePointer(ptr);}voiddoubleConstant(doubled){spew(".double %.16g",d);m_formatter.doubleConstant(d);}voidfloatConstant(floatf){spew(".float %.16g",f);m_formatter.floatConstant(f);}voidsimd128Constant(constvoid*data){constuint32_t*dw=reinterpret_cast<constuint32_t*>(data);spew(".int 0x%08x,0x%08x,0x%08x,0x%08x",dw[0],dw[1],dw[2],dw[3]);MOZ_ASSERT(m_formatter.isAligned(16));m_formatter.simd128Constant(data);}voidint32Constant(int32_ti){spew(".int %d",i);m_formatter.int32Constant(i);}voidint64Constant(int64_ti){spew(".quad %lld",(longlong)i);m_formatter.int64Constant(i);}// Linking & patching:voidassertValidJmpSrc(JmpSrcsrc){// The target offset is stored at offset - 4.MOZ_RELEASE_ASSERT(src.offset()>int32_t(sizeof(int32_t)));MOZ_RELEASE_ASSERT(size_t(src.offset())<=size());}boolnextJump(constJmpSrc&from,JmpSrc*next){// Sanity check - if the assembler has OOM'd, it will start overwriting// its internal buffer and thus our links could be garbage.if(oom())returnfalse;assertValidJmpSrc(from);constunsignedchar*code=m_formatter.data();int32_toffset=GetInt32(code+from.offset());if(offset==-1)returnfalse;if(MOZ_UNLIKELY(size_t(offset)>=size())){#ifdef NIGHTLY_BUILD// Stash some data on the stack so we can retrieve it from minidumps,// see bug 1124397.int32_tstartOffset=from.offset()-1;while(startOffset>=0&&code[startOffset]==0xe5)startOffset--;int32_tendOffset=from.offset()-1;while(endOffset<int32_t(size())&&code[endOffset]==0xe5)endOffset++;volatileuintptr_tdump[10];blackbox=dump;blackbox[0]=uintptr_t(0xABCD1234);blackbox[1]=uintptr_t(offset);blackbox[2]=uintptr_t(size());blackbox[3]=uintptr_t(from.offset());blackbox[4]=uintptr_t(code[from.offset()-5]);blackbox[5]=uintptr_t(code[from.offset()-4]);blackbox[6]=uintptr_t(code[from.offset()-3]);blackbox[7]=uintptr_t(startOffset);blackbox[8]=uintptr_t(endOffset);blackbox[9]=uintptr_t(0xFFFF7777);#endifMOZ_CRASH("nextJump bogus offset");}*next=JmpSrc(offset);returntrue;}voidsetNextJump(constJmpSrc&from,constJmpSrc&to){// Sanity check - if the assembler has OOM'd, it will start overwriting// its internal buffer and thus our links could be garbage.if(oom())return;assertValidJmpSrc(from);MOZ_RELEASE_ASSERT(to.offset()==-1||size_t(to.offset())<=size());unsignedchar*code=m_formatter.data();SetInt32(code+from.offset(),to.offset());}voidlinkJump(JmpSrcfrom,JmpDstto){MOZ_ASSERT(from.offset()!=-1);MOZ_ASSERT(to.offset()!=-1);// Sanity check - if the assembler has OOM'd, it will start overwriting// its internal buffer and thus our links could be garbage.if(oom())return;assertValidJmpSrc(from);MOZ_RELEASE_ASSERT(size_t(to.offset())<=size());spew(".set .Lfrom%d, .Llabel%d",from.offset(),to.offset());unsignedchar*code=m_formatter.data();SetRel32(code+from.offset(),code+to.offset());}voidexecutableCopy(void*dst){constunsignedchar*src=m_formatter.buffer();memcpy(dst,src,size());}MOZ_MUST_USEboolappendBuffer(constBaseAssembler&other){constunsignedchar*buf=other.m_formatter.buffer();boolret=m_formatter.append(buf,other.size());returnret;}protected:staticboolCAN_SIGN_EXTEND_8_32(int32_tvalue){returnvalue==(int32_t)(int8_t)value;}staticboolCAN_SIGN_EXTEND_16_32(int32_tvalue){returnvalue==(int32_t)(int16_t)value;}staticboolCAN_ZERO_EXTEND_8_32(int32_tvalue){returnvalue==(int32_t)(uint8_t)value;}staticboolCAN_ZERO_EXTEND_8H_32(int32_tvalue){returnvalue==(value&0xff00);}staticboolCAN_ZERO_EXTEND_16_32(int32_tvalue){returnvalue==(int32_t)(uint16_t)value;}staticboolCAN_ZERO_EXTEND_32_64(int32_tvalue){returnvalue>=0;}// Methods for encoding SIMD instructions via either legacy SSE encoding or// VEX encoding.booluseLegacySSEEncoding(XMMRegisterIDsrc0,XMMRegisterIDdst){// If we don't have AVX or it's disabled, use the legacy SSE encoding.if(!useVEX_){MOZ_ASSERT(src0==invalid_xmm||src0==dst,"Legacy SSE (pre-AVX) encoding requires the output register to be ""the same as the src0 input register");returntrue;}// If src0 is the same as the output register, we might as well use// the legacy SSE encoding, since it is smaller. However, this is only// beneficial as long as we're not using ymm registers anywhere.returnsrc0==dst;}booluseLegacySSEEncodingForVblendv(XMMRegisterIDmask,XMMRegisterIDsrc0,XMMRegisterIDdst){// Similar to useLegacySSEEncoding, but for vblendv the Legacy SSE// encoding also requires the mask to be in xmm0.if(!useVEX_){MOZ_ASSERT(src0==dst,"Legacy SSE (pre-AVX) encoding requires the output register to be ""the same as the src0 input register");MOZ_ASSERT(mask==xmm0,"Legacy SSE (pre-AVX) encoding for blendv requires the mask to be ""in xmm0");returntrue;}returnsrc0==dst&&mask==xmm0;}booluseLegacySSEEncodingForOtherOutput(){return!useVEX_;}constchar*legacySSEOpName(constchar*name){MOZ_ASSERT(name[0]=='v');returnname+1;}voidtwoByteOpSimd(constchar*name,VexOperandTypety,TwoByteOpcodeIDopcode,XMMRegisterIDrm,XMMRegisterIDsrc0,XMMRegisterIDdst){if(useLegacySSEEncoding(src0,dst)){if(IsXMMReversedOperands(opcode))spew("%-11s%s, %s",legacySSEOpName(name),XMMRegName(dst),XMMRegName(rm));elsespew("%-11s%s, %s",legacySSEOpName(name),XMMRegName(rm),XMMRegName(dst));m_formatter.legacySSEPrefix(ty);m_formatter.twoByteOp(opcode,(RegisterID)rm,dst);return;}if(src0==invalid_xmm){if(IsXMMReversedOperands(opcode))spew("%-11s%s, %s",name,XMMRegName(dst),XMMRegName(rm));elsespew("%-11s%s, %s",name,XMMRegName(rm),XMMRegName(dst));}else{spew("%-11s%s, %s, %s",name,XMMRegName(rm),XMMRegName(src0),XMMRegName(dst));}m_formatter.twoByteOpVex(ty,opcode,(RegisterID)rm,src0,dst);}voidtwoByteOpImmSimd(constchar*name,VexOperandTypety,TwoByteOpcodeIDopcode,uint32_timm,XMMRegisterIDrm,XMMRegisterIDsrc0,XMMRegisterIDdst){if(useLegacySSEEncoding(src0,dst)){spew("%-11s$0x%x, %s, %s",legacySSEOpName(name),imm,XMMRegName(rm),XMMRegName(dst));m_formatter.legacySSEPrefix(ty);m_formatter.twoByteOp(opcode,(RegisterID)rm,dst);m_formatter.immediate8u(imm);return;}if(src0==invalid_xmm)spew("%-11s$0x%x, %s, %s",name,imm,XMMRegName(rm),XMMRegName(dst));elsespew("%-11s$0x%x, %s, %s, %s",name,imm,XMMRegName(rm),XMMRegName(src0),XMMRegName(dst));m_formatter.twoByteOpVex(ty,opcode,(RegisterID)rm,src0,dst);m_formatter.immediate8u(imm);}voidtwoByteOpSimd(constchar*name,VexOperandTypety,TwoByteOpcodeIDopcode,int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){if(useLegacySSEEncoding(src0,dst)){if(IsXMMReversedOperands(opcode)){spew("%-11s%s, "MEM_ob,legacySSEOpName(name),XMMRegName(dst),ADDR_ob(offset,base));}else{spew("%-11s"MEM_ob", %s",legacySSEOpName(name),ADDR_ob(offset,base),XMMRegName(dst));}m_formatter.legacySSEPrefix(ty);m_formatter.twoByteOp(opcode,offset,base,dst);return;}if(src0==invalid_xmm){if(IsXMMReversedOperands(opcode))spew("%-11s%s, "MEM_ob,name,XMMRegName(dst),ADDR_ob(offset,base));elsespew("%-11s"MEM_ob", %s",name,ADDR_ob(offset,base),XMMRegName(dst));}else{spew("%-11s"MEM_ob", %s, %s",name,ADDR_ob(offset,base),XMMRegName(src0),XMMRegName(dst));}m_formatter.twoByteOpVex(ty,opcode,offset,base,src0,dst);}voidtwoByteOpSimd_disp32(constchar*name,VexOperandTypety,TwoByteOpcodeIDopcode,int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){if(useLegacySSEEncoding(src0,dst)){if(IsXMMReversedOperands(opcode))spew("%-11s%s, "MEM_o32b,legacySSEOpName(name),XMMRegName(dst),ADDR_o32b(offset,base));elsespew("%-11s"MEM_o32b", %s",legacySSEOpName(name),ADDR_o32b(offset,base),XMMRegName(dst));m_formatter.legacySSEPrefix(ty);m_formatter.twoByteOp_disp32(opcode,offset,base,dst);return;}if(src0==invalid_xmm){if(IsXMMReversedOperands(opcode))spew("%-11s%s, "MEM_o32b,name,XMMRegName(dst),ADDR_o32b(offset,base));elsespew("%-11s"MEM_o32b", %s",name,ADDR_o32b(offset,base),XMMRegName(dst));}else{spew("%-11s"MEM_o32b", %s, %s",name,ADDR_o32b(offset,base),XMMRegName(src0),XMMRegName(dst));}m_formatter.twoByteOpVex_disp32(ty,opcode,offset,base,src0,dst);}voidtwoByteOpImmSimd(constchar*name,VexOperandTypety,TwoByteOpcodeIDopcode,uint32_timm,int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){if(useLegacySSEEncoding(src0,dst)){spew("%-11s$0x%x, "MEM_ob", %s",legacySSEOpName(name),imm,ADDR_ob(offset,base),XMMRegName(dst));m_formatter.legacySSEPrefix(ty);m_formatter.twoByteOp(opcode,offset,base,dst);m_formatter.immediate8u(imm);return;}spew("%-11s$0x%x, "MEM_ob", %s, %s",name,imm,ADDR_ob(offset,base),XMMRegName(src0),XMMRegName(dst));m_formatter.twoByteOpVex(ty,opcode,offset,base,src0,dst);m_formatter.immediate8u(imm);}voidtwoByteOpSimd(constchar*name,VexOperandTypety,TwoByteOpcodeIDopcode,int32_toffset,RegisterIDbase,RegisterIDindex,intscale,XMMRegisterIDsrc0,XMMRegisterIDdst){if(useLegacySSEEncoding(src0,dst)){if(IsXMMReversedOperands(opcode)){spew("%-11s%s, "MEM_obs,legacySSEOpName(name),XMMRegName(dst),ADDR_obs(offset,base,index,scale));}else{spew("%-11s"MEM_obs", %s",legacySSEOpName(name),ADDR_obs(offset,base,index,scale),XMMRegName(dst));}m_formatter.legacySSEPrefix(ty);m_formatter.twoByteOp(opcode,offset,base,index,scale,dst);return;}if(src0==invalid_xmm){if(IsXMMReversedOperands(opcode)){spew("%-11s%s, "MEM_obs,name,XMMRegName(dst),ADDR_obs(offset,base,index,scale));}else{spew("%-11s"MEM_obs", %s",name,ADDR_obs(offset,base,index,scale),XMMRegName(dst));}}else{spew("%-11s"MEM_obs", %s, %s",name,ADDR_obs(offset,base,index,scale),XMMRegName(src0),XMMRegName(dst));}m_formatter.twoByteOpVex(ty,opcode,offset,base,index,scale,src0,dst);}voidtwoByteOpSimd(constchar*name,VexOperandTypety,TwoByteOpcodeIDopcode,constvoid*address,XMMRegisterIDsrc0,XMMRegisterIDdst){if(useLegacySSEEncoding(src0,dst)){if(IsXMMReversedOperands(opcode))spew("%-11s%s, %p",legacySSEOpName(name),XMMRegName(dst),address);elsespew("%-11s%p, %s",legacySSEOpName(name),address,XMMRegName(dst));m_formatter.legacySSEPrefix(ty);m_formatter.twoByteOp(opcode,address,dst);return;}if(src0==invalid_xmm){if(IsXMMReversedOperands(opcode))spew("%-11s%s, %p",name,XMMRegName(dst),address);elsespew("%-11s%p, %s",name,address,XMMRegName(dst));}else{spew("%-11s%p, %s, %s",name,address,XMMRegName(src0),XMMRegName(dst));}m_formatter.twoByteOpVex(ty,opcode,address,src0,dst);}voidtwoByteOpImmSimd(constchar*name,VexOperandTypety,TwoByteOpcodeIDopcode,uint32_timm,constvoid*address,XMMRegisterIDsrc0,XMMRegisterIDdst){if(useLegacySSEEncoding(src0,dst)){spew("%-11s$0x%x, %p, %s",legacySSEOpName(name),imm,address,XMMRegName(dst));m_formatter.legacySSEPrefix(ty);m_formatter.twoByteOp(opcode,address,dst);m_formatter.immediate8u(imm);return;}spew("%-11s$0x%x, %p, %s, %s",name,imm,address,XMMRegName(src0),XMMRegName(dst));m_formatter.twoByteOpVex(ty,opcode,address,src0,dst);m_formatter.immediate8u(imm);}voidtwoByteOpInt32Simd(constchar*name,VexOperandTypety,TwoByteOpcodeIDopcode,RegisterIDrm,XMMRegisterIDsrc0,XMMRegisterIDdst){if(useLegacySSEEncoding(src0,dst)){if(IsXMMReversedOperands(opcode))spew("%-11s%s, %s",legacySSEOpName(name),XMMRegName(dst),GPReg32Name(rm));elsespew("%-11s%s, %s",legacySSEOpName(name),GPReg32Name(rm),XMMRegName(dst));m_formatter.legacySSEPrefix(ty);m_formatter.twoByteOp(opcode,rm,dst);return;}if(src0==invalid_xmm){if(IsXMMReversedOperands(opcode))spew("%-11s%s, %s",name,XMMRegName(dst),GPReg32Name(rm));elsespew("%-11s%s, %s",name,GPReg32Name(rm),XMMRegName(dst));}else{spew("%-11s%s, %s, %s",name,GPReg32Name(rm),XMMRegName(src0),XMMRegName(dst));}m_formatter.twoByteOpVex(ty,opcode,rm,src0,dst);}voidtwoByteOpSimdInt32(constchar*name,VexOperandTypety,TwoByteOpcodeIDopcode,XMMRegisterIDrm,RegisterIDdst){if(useLegacySSEEncodingForOtherOutput()){if(IsXMMReversedOperands(opcode))spew("%-11s%s, %s",legacySSEOpName(name),GPReg32Name(dst),XMMRegName(rm));elseif(opcode==OP2_MOVD_EdVd)spew("%-11s%s, %s",legacySSEOpName(name),XMMRegName((XMMRegisterID)dst),GPReg32Name((RegisterID)rm));elsespew("%-11s%s, %s",legacySSEOpName(name),XMMRegName(rm),GPReg32Name(dst));m_formatter.legacySSEPrefix(ty);m_formatter.twoByteOp(opcode,(RegisterID)rm,dst);return;}if(IsXMMReversedOperands(opcode))spew("%-11s%s, %s",name,GPReg32Name(dst),XMMRegName(rm));elseif(opcode==OP2_MOVD_EdVd)spew("%-11s%s, %s",name,XMMRegName((XMMRegisterID)dst),GPReg32Name((RegisterID)rm));elsespew("%-11s%s, %s",name,XMMRegName(rm),GPReg32Name(dst));m_formatter.twoByteOpVex(ty,opcode,(RegisterID)rm,invalid_xmm,dst);}voidtwoByteOpImmSimdInt32(constchar*name,VexOperandTypety,TwoByteOpcodeIDopcode,uint32_timm,XMMRegisterIDrm,RegisterIDdst){if(useLegacySSEEncodingForOtherOutput()){spew("%-11s$0x%x, %s, %s",legacySSEOpName(name),imm,XMMRegName(rm),GPReg32Name(dst));m_formatter.legacySSEPrefix(ty);m_formatter.twoByteOp(opcode,(RegisterID)rm,dst);m_formatter.immediate8u(imm);return;}spew("%-11s$0x%x, %s, %s",name,imm,XMMRegName(rm),GPReg32Name(dst));m_formatter.twoByteOpVex(ty,opcode,(RegisterID)rm,invalid_xmm,dst);m_formatter.immediate8u(imm);}voidtwoByteOpImmInt32Simd(constchar*name,VexOperandTypety,TwoByteOpcodeIDopcode,uint32_timm,RegisterIDrm,XMMRegisterIDsrc0,XMMRegisterIDdst){if(useLegacySSEEncodingForOtherOutput()){spew("%-11s$0x%x, %s, %s",legacySSEOpName(name),imm,GPReg32Name(rm),XMMRegName(dst));m_formatter.legacySSEPrefix(ty);m_formatter.twoByteOp(opcode,rm,dst);m_formatter.immediate8u(imm);return;}spew("%-11s$0x%x, %s, %s",name,imm,GPReg32Name(rm),XMMRegName(dst));m_formatter.twoByteOpVex(ty,opcode,rm,src0,dst);m_formatter.immediate8u(imm);}voidtwoByteOpSimdFlags(constchar*name,VexOperandTypety,TwoByteOpcodeIDopcode,XMMRegisterIDrm,XMMRegisterIDreg){if(useLegacySSEEncodingForOtherOutput()){spew("%-11s%s, %s",legacySSEOpName(name),XMMRegName(rm),XMMRegName(reg));m_formatter.legacySSEPrefix(ty);m_formatter.twoByteOp(opcode,(RegisterID)rm,reg);return;}spew("%-11s%s, %s",name,XMMRegName(rm),XMMRegName(reg));m_formatter.twoByteOpVex(ty,opcode,(RegisterID)rm,invalid_xmm,(XMMRegisterID)reg);}voidtwoByteOpSimdFlags(constchar*name,VexOperandTypety,TwoByteOpcodeIDopcode,int32_toffset,RegisterIDbase,XMMRegisterIDreg){if(useLegacySSEEncodingForOtherOutput()){spew("%-11s"MEM_ob", %s",legacySSEOpName(name),ADDR_ob(offset,base),XMMRegName(reg));m_formatter.legacySSEPrefix(ty);m_formatter.twoByteOp(opcode,offset,base,reg);return;}spew("%-11s"MEM_ob", %s",name,ADDR_ob(offset,base),XMMRegName(reg));m_formatter.twoByteOpVex(ty,opcode,offset,base,invalid_xmm,(XMMRegisterID)reg);}voidthreeByteOpSimd(constchar*name,VexOperandTypety,ThreeByteOpcodeIDopcode,ThreeByteEscapeescape,XMMRegisterIDrm,XMMRegisterIDsrc0,XMMRegisterIDdst){if(useLegacySSEEncoding(src0,dst)){spew("%-11s%s, %s",legacySSEOpName(name),XMMRegName(rm),XMMRegName(dst));m_formatter.legacySSEPrefix(ty);m_formatter.threeByteOp(opcode,escape,(RegisterID)rm,dst);return;}spew("%-11s%s, %s, %s",name,XMMRegName(rm),XMMRegName(src0),XMMRegName(dst));m_formatter.threeByteOpVex(ty,opcode,escape,(RegisterID)rm,src0,dst);}voidthreeByteOpImmSimd(constchar*name,VexOperandTypety,ThreeByteOpcodeIDopcode,ThreeByteEscapeescape,uint32_timm,XMMRegisterIDrm,XMMRegisterIDsrc0,XMMRegisterIDdst){if(useLegacySSEEncoding(src0,dst)){spew("%-11s$0x%x, %s, %s",legacySSEOpName(name),imm,XMMRegName(rm),XMMRegName(dst));m_formatter.legacySSEPrefix(ty);m_formatter.threeByteOp(opcode,escape,(RegisterID)rm,dst);m_formatter.immediate8u(imm);return;}spew("%-11s$0x%x, %s, %s, %s",name,imm,XMMRegName(rm),XMMRegName(src0),XMMRegName(dst));m_formatter.threeByteOpVex(ty,opcode,escape,(RegisterID)rm,src0,dst);m_formatter.immediate8u(imm);}voidthreeByteOpSimd(constchar*name,VexOperandTypety,ThreeByteOpcodeIDopcode,ThreeByteEscapeescape,int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){if(useLegacySSEEncoding(src0,dst)){spew("%-11s"MEM_ob", %s",legacySSEOpName(name),ADDR_ob(offset,base),XMMRegName(dst));m_formatter.legacySSEPrefix(ty);m_formatter.threeByteOp(opcode,escape,offset,base,dst);return;}spew("%-11s"MEM_ob", %s, %s",name,ADDR_ob(offset,base),XMMRegName(src0),XMMRegName(dst));m_formatter.threeByteOpVex(ty,opcode,escape,offset,base,src0,dst);}voidthreeByteOpImmSimd(constchar*name,VexOperandTypety,ThreeByteOpcodeIDopcode,ThreeByteEscapeescape,uint32_timm,int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){if(useLegacySSEEncoding(src0,dst)){spew("%-11s$0x%x, "MEM_ob", %s",legacySSEOpName(name),imm,ADDR_ob(offset,base),XMMRegName(dst));m_formatter.legacySSEPrefix(ty);m_formatter.threeByteOp(opcode,escape,offset,base,dst);m_formatter.immediate8u(imm);return;}spew("%-11s$0x%x, "MEM_ob", %s, %s",name,imm,ADDR_ob(offset,base),XMMRegName(src0),XMMRegName(dst));m_formatter.threeByteOpVex(ty,opcode,escape,offset,base,src0,dst);m_formatter.immediate8u(imm);}voidthreeByteOpSimd(constchar*name,VexOperandTypety,ThreeByteOpcodeIDopcode,ThreeByteEscapeescape,constvoid*address,XMMRegisterIDsrc0,XMMRegisterIDdst){if(useLegacySSEEncoding(src0,dst)){spew("%-11s%p, %s",legacySSEOpName(name),address,XMMRegName(dst));m_formatter.legacySSEPrefix(ty);m_formatter.threeByteOp(opcode,escape,address,dst);return;}spew("%-11s%p, %s, %s",name,address,XMMRegName(src0),XMMRegName(dst));m_formatter.threeByteOpVex(ty,opcode,escape,address,src0,dst);}voidthreeByteOpImmInt32Simd(constchar*name,VexOperandTypety,ThreeByteOpcodeIDopcode,ThreeByteEscapeescape,uint32_timm,RegisterIDsrc1,XMMRegisterIDsrc0,XMMRegisterIDdst){if(useLegacySSEEncoding(src0,dst)){spew("%-11s$0x%x, %s, %s",legacySSEOpName(name),imm,GPReg32Name(src1),XMMRegName(dst));m_formatter.legacySSEPrefix(ty);m_formatter.threeByteOp(opcode,escape,src1,dst);m_formatter.immediate8u(imm);return;}spew("%-11s$0x%x, %s, %s, %s",name,imm,GPReg32Name(src1),XMMRegName(src0),XMMRegName(dst));m_formatter.threeByteOpVex(ty,opcode,escape,src1,src0,dst);m_formatter.immediate8u(imm);}voidthreeByteOpImmInt32Simd(constchar*name,VexOperandTypety,ThreeByteOpcodeIDopcode,ThreeByteEscapeescape,uint32_timm,int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){if(useLegacySSEEncoding(src0,dst)){spew("%-11s$0x%x, "MEM_ob", %s",legacySSEOpName(name),imm,ADDR_ob(offset,base),XMMRegName(dst));m_formatter.legacySSEPrefix(ty);m_formatter.threeByteOp(opcode,escape,offset,base,dst);m_formatter.immediate8u(imm);return;}spew("%-11s$0x%x, "MEM_ob", %s, %s",name,imm,ADDR_ob(offset,base),XMMRegName(src0),XMMRegName(dst));m_formatter.threeByteOpVex(ty,opcode,escape,offset,base,src0,dst);m_formatter.immediate8u(imm);}voidthreeByteOpImmSimdInt32(constchar*name,VexOperandTypety,ThreeByteOpcodeIDopcode,ThreeByteEscapeescape,uint32_timm,XMMRegisterIDsrc,RegisterIDdst){if(useLegacySSEEncodingForOtherOutput()){spew("%-11s$0x%x, %s, %s",legacySSEOpName(name),imm,XMMRegName(src),GPReg32Name(dst));m_formatter.legacySSEPrefix(ty);m_formatter.threeByteOp(opcode,escape,(RegisterID)src,dst);m_formatter.immediate8u(imm);return;}if(opcode==OP3_PEXTRD_EdVdqIb)spew("%-11s$0x%x, %s, %s",name,imm,XMMRegName((XMMRegisterID)dst),GPReg32Name((RegisterID)src));elsespew("%-11s$0x%x, %s, %s",name,imm,XMMRegName(src),GPReg32Name(dst));m_formatter.threeByteOpVex(ty,opcode,escape,(RegisterID)src,invalid_xmm,dst);m_formatter.immediate8u(imm);}voidthreeByteOpImmSimdInt32(constchar*name,VexOperandTypety,ThreeByteOpcodeIDopcode,ThreeByteEscapeescape,uint32_timm,int32_toffset,RegisterIDbase,RegisterIDdst){if(useLegacySSEEncodingForOtherOutput()){spew("%-11s$0x%x, "MEM_ob", %s",legacySSEOpName(name),imm,ADDR_ob(offset,base),GPReg32Name(dst));m_formatter.legacySSEPrefix(ty);m_formatter.threeByteOp(opcode,escape,offset,base,dst);m_formatter.immediate8u(imm);return;}spew("%-11s$0x%x, "MEM_ob", %s",name,imm,ADDR_ob(offset,base),GPReg32Name(dst));m_formatter.threeByteOpVex(ty,opcode,escape,offset,base,invalid_xmm,dst);m_formatter.immediate8u(imm);}// Blendv is a three-byte op, but the VEX encoding has a different opcode// than the SSE encoding, so we handle it specially.voidvblendvOpSimd(XMMRegisterIDmask,XMMRegisterIDrm,XMMRegisterIDsrc0,XMMRegisterIDdst){if(useLegacySSEEncodingForVblendv(mask,src0,dst)){spew("blendvps %s, %s",XMMRegName(rm),XMMRegName(dst));// Even though a "ps" instruction, vblendv is encoded with the "pd" prefix.m_formatter.legacySSEPrefix(VEX_PD);m_formatter.threeByteOp(OP3_BLENDVPS_VdqWdq,ESCAPE_3A,(RegisterID)rm,dst);return;}spew("vblendvps %s, %s, %s, %s",XMMRegName(mask),XMMRegName(rm),XMMRegName(src0),XMMRegName(dst));// Even though a "ps" instruction, vblendv is encoded with the "pd" prefix.m_formatter.vblendvOpVex(VEX_PD,OP3_VBLENDVPS_VdqWdq,ESCAPE_3A,mask,(RegisterID)rm,src0,dst);}voidvblendvOpSimd(XMMRegisterIDmask,int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,XMMRegisterIDdst){if(useLegacySSEEncodingForVblendv(mask,src0,dst)){spew("blendvps "MEM_ob", %s",ADDR_ob(offset,base),XMMRegName(dst));// Even though a "ps" instruction, vblendv is encoded with the "pd" prefix.m_formatter.legacySSEPrefix(VEX_PD);m_formatter.threeByteOp(OP3_BLENDVPS_VdqWdq,ESCAPE_3A,offset,base,dst);return;}spew("vblendvps %s, "MEM_ob", %s, %s",XMMRegName(mask),ADDR_ob(offset,base),XMMRegName(src0),XMMRegName(dst));// Even though a "ps" instruction, vblendv is encoded with the "pd" prefix.m_formatter.vblendvOpVex(VEX_PD,OP3_VBLENDVPS_VdqWdq,ESCAPE_3A,mask,offset,base,src0,dst);}voidshiftOpImmSimd(constchar*name,TwoByteOpcodeIDopcode,ShiftIDshiftKind,uint32_timm,XMMRegisterIDsrc,XMMRegisterIDdst){if(useLegacySSEEncoding(src,dst)){spew("%-11s$%d, %s",legacySSEOpName(name),imm,XMMRegName(dst));m_formatter.legacySSEPrefix(VEX_PD);m_formatter.twoByteOp(opcode,(RegisterID)dst,(int)shiftKind);m_formatter.immediate8u(imm);return;}spew("%-11s$%d, %s, %s",name,imm,XMMRegName(src),XMMRegName(dst));m_formatter.twoByteOpVex(VEX_PD,opcode,(RegisterID)dst,src,(int)shiftKind);m_formatter.immediate8u(imm);}classX86InstructionFormatter{public:// Legacy prefix bytes://// These are emmitted prior to the instruction.voidprefix(OneByteOpcodeIDpre){m_buffer.putByte(pre);}voidlegacySSEPrefix(VexOperandTypety){switch(ty){caseVEX_PS:break;caseVEX_PD:prefix(PRE_SSE_66);break;caseVEX_SS:prefix(PRE_SSE_F3);break;caseVEX_SD:prefix(PRE_SSE_F2);break;}}// Word-sized operands / no operand instruction formatters.//// In addition to the opcode, the following operand permutations are supported:// * None - instruction takes no operands.// * One register - the low three bits of the RegisterID are added into the opcode.// * Two registers - encode a register form ModRm (for all ModRm formats, the reg field is passed first, and a GroupOpcodeID may be passed in its place).// * Three argument ModRM - a register, and a register and an offset describing a memory operand.// * Five argument ModRM - a register, and a base register, an index, scale, and offset describing a memory operand.//// For 32-bit x86 targets, the address operand may also be provided as a// void*. On 64-bit targets REX prefixes will be planted as necessary,// where high numbered registers are used.//// The twoByteOp methods plant two-byte Intel instructions sequences// (first opcode byte 0x0F).voidoneByteOp(OneByteOpcodeIDopcode){m_buffer.ensureSpace(MaxInstructionSize);m_buffer.putByteUnchecked(opcode);}voidoneByteOp(OneByteOpcodeIDopcode,RegisterIDreg){m_buffer.ensureSpace(MaxInstructionSize);emitRexIfNeeded(0,0,reg);m_buffer.putByteUnchecked(opcode+(reg&7));}voidoneByteOp(OneByteOpcodeIDopcode,RegisterIDrm,intreg){m_buffer.ensureSpace(MaxInstructionSize);emitRexIfNeeded(reg,0,rm);m_buffer.putByteUnchecked(opcode);registerModRM(rm,reg);}voidoneByteOp(OneByteOpcodeIDopcode,int32_toffset,RegisterIDbase,intreg){m_buffer.ensureSpace(MaxInstructionSize);emitRexIfNeeded(reg,0,base);m_buffer.putByteUnchecked(opcode);memoryModRM(offset,base,reg);}voidoneByteOp_disp32(OneByteOpcodeIDopcode,int32_toffset,RegisterIDbase,intreg){m_buffer.ensureSpace(MaxInstructionSize);emitRexIfNeeded(reg,0,base);m_buffer.putByteUnchecked(opcode);memoryModRM_disp32(offset,base,reg);}voidoneByteOp(OneByteOpcodeIDopcode,int32_toffset,RegisterIDbase,RegisterIDindex,intscale,intreg){m_buffer.ensureSpace(MaxInstructionSize);emitRexIfNeeded(reg,index,base);m_buffer.putByteUnchecked(opcode);memoryModRM(offset,base,index,scale,reg);}voidoneByteOp_disp32(OneByteOpcodeIDopcode,int32_toffset,RegisterIDindex,intscale,intreg){m_buffer.ensureSpace(MaxInstructionSize);emitRexIfNeeded(reg,index,0);m_buffer.putByteUnchecked(opcode);memoryModRM_disp32(offset,index,scale,reg);}voidoneByteOp(OneByteOpcodeIDopcode,constvoid*address,intreg){m_buffer.ensureSpace(MaxInstructionSize);emitRexIfNeeded(reg,0,0);m_buffer.putByteUnchecked(opcode);memoryModRM_disp32(address,reg);}voidoneByteOp_disp32(OneByteOpcodeIDopcode,constvoid*address,intreg){m_buffer.ensureSpace(MaxInstructionSize);emitRexIfNeeded(reg,0,0);m_buffer.putByteUnchecked(opcode);memoryModRM_disp32(address,reg);}#ifdef JS_CODEGEN_X64voidoneByteRipOp(OneByteOpcodeIDopcode,intripOffset,intreg){m_buffer.ensureSpace(MaxInstructionSize);emitRexIfNeeded(reg,0,0);m_buffer.putByteUnchecked(opcode);putModRm(ModRmMemoryNoDisp,noBase,reg);m_buffer.putIntUnchecked(ripOffset);}voidoneByteRipOp64(OneByteOpcodeIDopcode,intripOffset,intreg){m_buffer.ensureSpace(MaxInstructionSize);emitRexW(reg,0,0);m_buffer.putByteUnchecked(opcode);putModRm(ModRmMemoryNoDisp,noBase,reg);m_buffer.putIntUnchecked(ripOffset);}voidtwoByteRipOp(TwoByteOpcodeIDopcode,intripOffset,intreg){m_buffer.ensureSpace(MaxInstructionSize);emitRexIfNeeded(reg,0,0);m_buffer.putByteUnchecked(OP_2BYTE_ESCAPE);m_buffer.putByteUnchecked(opcode);putModRm(ModRmMemoryNoDisp,noBase,reg);m_buffer.putIntUnchecked(ripOffset);}voidtwoByteRipOpVex(VexOperandTypety,TwoByteOpcodeIDopcode,intripOffset,XMMRegisterIDsrc0,XMMRegisterIDreg){intr=(reg>>3),x=0,b=0;intm=1;// 0x0Fintw=0,v=src0,l=0;threeOpVex(ty,r,x,b,m,w,v,l,opcode);putModRm(ModRmMemoryNoDisp,noBase,reg);m_buffer.putIntUnchecked(ripOffset);}#endifvoidtwoByteOp(TwoByteOpcodeIDopcode){m_buffer.ensureSpace(MaxInstructionSize);m_buffer.putByteUnchecked(OP_2BYTE_ESCAPE);m_buffer.putByteUnchecked(opcode);}voidtwoByteOp(TwoByteOpcodeIDopcode,RegisterIDrm,intreg){m_buffer.ensureSpace(MaxInstructionSize);emitRexIfNeeded(reg,0,rm);m_buffer.putByteUnchecked(OP_2BYTE_ESCAPE);m_buffer.putByteUnchecked(opcode);registerModRM(rm,reg);}voidtwoByteOpVex(VexOperandTypety,TwoByteOpcodeIDopcode,RegisterIDrm,XMMRegisterIDsrc0,intreg){intr=(reg>>3),x=0,b=(rm>>3);intm=1;// 0x0Fintw=0,v=src0,l=0;threeOpVex(ty,r,x,b,m,w,v,l,opcode);registerModRM(rm,reg);}voidtwoByteOp(TwoByteOpcodeIDopcode,int32_toffset,RegisterIDbase,intreg){m_buffer.ensureSpace(MaxInstructionSize);emitRexIfNeeded(reg,0,base);m_buffer.putByteUnchecked(OP_2BYTE_ESCAPE);m_buffer.putByteUnchecked(opcode);memoryModRM(offset,base,reg);}voidtwoByteOpVex(VexOperandTypety,TwoByteOpcodeIDopcode,int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,intreg){intr=(reg>>3),x=0,b=(base>>3);intm=1;// 0x0Fintw=0,v=src0,l=0;threeOpVex(ty,r,x,b,m,w,v,l,opcode);memoryModRM(offset,base,reg);}voidtwoByteOp_disp32(TwoByteOpcodeIDopcode,int32_toffset,RegisterIDbase,intreg){m_buffer.ensureSpace(MaxInstructionSize);emitRexIfNeeded(reg,0,base);m_buffer.putByteUnchecked(OP_2BYTE_ESCAPE);m_buffer.putByteUnchecked(opcode);memoryModRM_disp32(offset,base,reg);}voidtwoByteOpVex_disp32(VexOperandTypety,TwoByteOpcodeIDopcode,int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,intreg){intr=(reg>>3),x=0,b=(base>>3);intm=1;// 0x0Fintw=0,v=src0,l=0;threeOpVex(ty,r,x,b,m,w,v,l,opcode);memoryModRM_disp32(offset,base,reg);}voidtwoByteOp(TwoByteOpcodeIDopcode,int32_toffset,RegisterIDbase,RegisterIDindex,intscale,intreg){m_buffer.ensureSpace(MaxInstructionSize);emitRexIfNeeded(reg,index,base);m_buffer.putByteUnchecked(OP_2BYTE_ESCAPE);m_buffer.putByteUnchecked(opcode);memoryModRM(offset,base,index,scale,reg);}voidtwoByteOpVex(VexOperandTypety,TwoByteOpcodeIDopcode,int32_toffset,RegisterIDbase,RegisterIDindex,intscale,XMMRegisterIDsrc0,intreg){intr=(reg>>3),x=(index>>3),b=(base>>3);intm=1;// 0x0Fintw=0,v=src0,l=0;threeOpVex(ty,r,x,b,m,w,v,l,opcode);memoryModRM(offset,base,index,scale,reg);}voidtwoByteOp(TwoByteOpcodeIDopcode,constvoid*address,intreg){m_buffer.ensureSpace(MaxInstructionSize);emitRexIfNeeded(reg,0,0);m_buffer.putByteUnchecked(OP_2BYTE_ESCAPE);m_buffer.putByteUnchecked(opcode);memoryModRM(address,reg);}voidtwoByteOpVex(VexOperandTypety,TwoByteOpcodeIDopcode,constvoid*address,XMMRegisterIDsrc0,intreg){intr=(reg>>3),x=0,b=0;intm=1;// 0x0Fintw=0,v=src0,l=0;threeOpVex(ty,r,x,b,m,w,v,l,opcode);memoryModRM(address,reg);}voidthreeByteOp(ThreeByteOpcodeIDopcode,ThreeByteEscapeescape,RegisterIDrm,intreg){m_buffer.ensureSpace(MaxInstructionSize);emitRexIfNeeded(reg,0,rm);m_buffer.putByteUnchecked(OP_2BYTE_ESCAPE);m_buffer.putByteUnchecked(escape);m_buffer.putByteUnchecked(opcode);registerModRM(rm,reg);}voidthreeByteOpVex(VexOperandTypety,ThreeByteOpcodeIDopcode,ThreeByteEscapeescape,RegisterIDrm,XMMRegisterIDsrc0,intreg){intr=(reg>>3),x=0,b=(rm>>3);intm=0,w=0,v=src0,l=0;switch(escape){caseESCAPE_38:m=2;break;caseESCAPE_3A:m=3;break;default:MOZ_CRASH("unexpected escape");}threeOpVex(ty,r,x,b,m,w,v,l,opcode);registerModRM(rm,reg);}voidthreeByteOp(ThreeByteOpcodeIDopcode,ThreeByteEscapeescape,int32_toffset,RegisterIDbase,intreg){m_buffer.ensureSpace(MaxInstructionSize);emitRexIfNeeded(reg,0,base);m_buffer.putByteUnchecked(OP_2BYTE_ESCAPE);m_buffer.putByteUnchecked(escape);m_buffer.putByteUnchecked(opcode);memoryModRM(offset,base,reg);}voidthreeByteOpVex(VexOperandTypety,ThreeByteOpcodeIDopcode,ThreeByteEscapeescape,int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,intreg){intr=(reg>>3),x=0,b=(base>>3);intm=0,w=0,v=src0,l=0;switch(escape){caseESCAPE_38:m=2;break;caseESCAPE_3A:m=3;break;default:MOZ_CRASH("unexpected escape");}threeOpVex(ty,r,x,b,m,w,v,l,opcode);memoryModRM(offset,base,reg);}voidthreeByteOp(ThreeByteOpcodeIDopcode,ThreeByteEscapeescape,constvoid*address,intreg){m_buffer.ensureSpace(MaxInstructionSize);emitRexIfNeeded(reg,0,0);m_buffer.putByteUnchecked(OP_2BYTE_ESCAPE);m_buffer.putByteUnchecked(escape);m_buffer.putByteUnchecked(opcode);memoryModRM(address,reg);}voidthreeByteOpVex(VexOperandTypety,ThreeByteOpcodeIDopcode,ThreeByteEscapeescape,constvoid*address,XMMRegisterIDsrc0,intreg){intr=(reg>>3),x=0,b=0;intm=0,w=0,v=src0,l=0;switch(escape){caseESCAPE_38:m=2;break;caseESCAPE_3A:m=3;break;default:MOZ_CRASH("unexpected escape");}threeOpVex(ty,r,x,b,m,w,v,l,opcode);memoryModRM(address,reg);}voidvblendvOpVex(VexOperandTypety,ThreeByteOpcodeIDopcode,ThreeByteEscapeescape,XMMRegisterIDmask,RegisterIDrm,XMMRegisterIDsrc0,intreg){intr=(reg>>3),x=0,b=(rm>>3);intm=0,w=0,v=src0,l=0;switch(escape){caseESCAPE_38:m=2;break;caseESCAPE_3A:m=3;break;default:MOZ_CRASH("unexpected escape");}threeOpVex(ty,r,x,b,m,w,v,l,opcode);registerModRM(rm,reg);immediate8u(mask<<4);}voidvblendvOpVex(VexOperandTypety,ThreeByteOpcodeIDopcode,ThreeByteEscapeescape,XMMRegisterIDmask,int32_toffset,RegisterIDbase,XMMRegisterIDsrc0,intreg){intr=(reg>>3),x=0,b=(base>>3);intm=0,w=0,v=src0,l=0;switch(escape){caseESCAPE_38:m=2;break;caseESCAPE_3A:m=3;break;default:MOZ_CRASH("unexpected escape");}threeOpVex(ty,r,x,b,m,w,v,l,opcode);memoryModRM(offset,base,reg);immediate8u(mask<<4);}#ifdef JS_CODEGEN_X64// Quad-word-sized operands://// Used to format 64-bit operantions, planting a REX.w prefix. When// planting d64 or f64 instructions, not requiring a REX.w prefix, the// normal (non-'64'-postfixed) formatters should be used.voidoneByteOp64(OneByteOpcodeIDopcode){m_buffer.ensureSpace(MaxInstructionSize);emitRexW(0,0,0);m_buffer.putByteUnchecked(opcode);}voidoneByteOp64(OneByteOpcodeIDopcode,RegisterIDreg){m_buffer.ensureSpace(MaxInstructionSize);emitRexW(0,0,reg);m_buffer.putByteUnchecked(opcode+(reg&7));}voidoneByteOp64(OneByteOpcodeIDopcode,RegisterIDrm,intreg){m_buffer.ensureSpace(MaxInstructionSize);emitRexW(reg,0,rm);m_buffer.putByteUnchecked(opcode);registerModRM(rm,reg);}voidoneByteOp64(OneByteOpcodeIDopcode,int32_toffset,RegisterIDbase,intreg){m_buffer.ensureSpace(MaxInstructionSize);emitRexW(reg,0,base);m_buffer.putByteUnchecked(opcode);memoryModRM(offset,base,reg);}voidoneByteOp64_disp32(OneByteOpcodeIDopcode,int32_toffset,RegisterIDbase,intreg){m_buffer.ensureSpace(MaxInstructionSize);emitRexW(reg,0,base);m_buffer.putByteUnchecked(opcode);memoryModRM_disp32(offset,base,reg);}voidoneByteOp64(OneByteOpcodeIDopcode,int32_toffset,RegisterIDbase,RegisterIDindex,intscale,intreg){m_buffer.ensureSpace(MaxInstructionSize);emitRexW(reg,index,base);m_buffer.putByteUnchecked(opcode);memoryModRM(offset,base,index,scale,reg);}voidoneByteOp64(OneByteOpcodeIDopcode,constvoid*address,intreg){m_buffer.ensureSpace(MaxInstructionSize);emitRexW(reg,0,0);m_buffer.putByteUnchecked(opcode);memoryModRM(address,reg);}voidtwoByteOp64(TwoByteOpcodeIDopcode,RegisterIDrm,intreg){m_buffer.ensureSpace(MaxInstructionSize);emitRexW(reg,0,rm);m_buffer.putByteUnchecked(OP_2BYTE_ESCAPE);m_buffer.putByteUnchecked(opcode);registerModRM(rm,reg);}voidtwoByteOp64(TwoByteOpcodeIDopcode,intoffset,RegisterIDbase,intreg){m_buffer.ensureSpace(MaxInstructionSize);emitRexW(reg,0,base);m_buffer.putByteUnchecked(OP_2BYTE_ESCAPE);m_buffer.putByteUnchecked(opcode);memoryModRM(offset,base,reg);}voidtwoByteOp64(TwoByteOpcodeIDopcode,intoffset,RegisterIDbase,RegisterIDindex,intscale,intreg){m_buffer.ensureSpace(MaxInstructionSize);emitRexW(reg,index,base);m_buffer.putByteUnchecked(OP_2BYTE_ESCAPE);m_buffer.putByteUnchecked(opcode);memoryModRM(offset,base,index,scale,reg);}voidtwoByteOp64(TwoByteOpcodeIDopcode,constvoid*address,intreg){m_buffer.ensureSpace(MaxInstructionSize);emitRexW(reg,0,0);m_buffer.putByteUnchecked(OP_2BYTE_ESCAPE);m_buffer.putByteUnchecked(opcode);memoryModRM(address,reg);}voidtwoByteOpVex64(VexOperandTypety,TwoByteOpcodeIDopcode,RegisterIDrm,XMMRegisterIDsrc0,XMMRegisterIDreg){intr=(reg>>3),x=0,b=(rm>>3);intm=1;// 0x0Fintw=1,v=src0,l=0;threeOpVex(ty,r,x,b,m,w,v,l,opcode);registerModRM(rm,reg);}#endif// Byte-operands://// These methods format byte operations. Byte operations differ from// the normal formatters in the circumstances under which they will// decide to emit REX prefixes. These should be used where any register// operand signifies a byte register.//// The disctinction is due to the handling of register numbers in the// range 4..7 on x86-64. These register numbers may either represent// the second byte of the first four registers (ah..bh) or the first// byte of the second four registers (spl..dil).//// Address operands should still be checked using regRequiresRex(),// while byteRegRequiresRex() is provided to check byte register// operands.voidoneByteOp8(OneByteOpcodeIDopcode){m_buffer.ensureSpace(MaxInstructionSize);m_buffer.putByteUnchecked(opcode);}voidoneByteOp8(OneByteOpcodeIDopcode,RegisterIDr){m_buffer.ensureSpace(MaxInstructionSize);emitRexIf(byteRegRequiresRex(r),0,0,r);m_buffer.putByteUnchecked(opcode+(r&7));}voidoneByteOp8(OneByteOpcodeIDopcode,RegisterIDrm,GroupOpcodeIDgroupOp){m_buffer.ensureSpace(MaxInstructionSize);emitRexIf(byteRegRequiresRex(rm),0,0,rm);m_buffer.putByteUnchecked(opcode);registerModRM(rm,groupOp);}// Like oneByteOp8, but never emits a REX prefix.voidoneByteOp8_norex(OneByteOpcodeIDopcode,HRegisterIDrm,GroupOpcodeIDgroupOp){MOZ_ASSERT(!regRequiresRex(RegisterID(rm)));m_buffer.ensureSpace(MaxInstructionSize);m_buffer.putByteUnchecked(opcode);registerModRM(RegisterID(rm),groupOp);}voidoneByteOp8(OneByteOpcodeIDopcode,int32_toffset,RegisterIDbase,RegisterIDreg){m_buffer.ensureSpace(MaxInstructionSize);emitRexIf(byteRegRequiresRex(reg),reg,0,base);m_buffer.putByteUnchecked(opcode);memoryModRM(offset,base,reg);}voidoneByteOp8_disp32(OneByteOpcodeIDopcode,int32_toffset,RegisterIDbase,RegisterIDreg){m_buffer.ensureSpace(MaxInstructionSize);emitRexIf(byteRegRequiresRex(reg),reg,0,base);m_buffer.putByteUnchecked(opcode);memoryModRM_disp32(offset,base,reg);}voidoneByteOp8(OneByteOpcodeIDopcode,int32_toffset,RegisterIDbase,RegisterIDindex,intscale,RegisterIDreg){m_buffer.ensureSpace(MaxInstructionSize);emitRexIf(byteRegRequiresRex(reg),reg,index,base);m_buffer.putByteUnchecked(opcode);memoryModRM(offset,base,index,scale,reg);}voidoneByteOp8(OneByteOpcodeIDopcode,constvoid*address,RegisterIDreg){m_buffer.ensureSpace(MaxInstructionSize);emitRexIf(byteRegRequiresRex(reg),reg,0,0);m_buffer.putByteUnchecked(opcode);memoryModRM_disp32(address,reg);}voidtwoByteOp8(TwoByteOpcodeIDopcode,RegisterIDrm,RegisterIDreg){m_buffer.ensureSpace(MaxInstructionSize);emitRexIf(byteRegRequiresRex(reg)|byteRegRequiresRex(rm),reg,0,rm);m_buffer.putByteUnchecked(OP_2BYTE_ESCAPE);m_buffer.putByteUnchecked(opcode);registerModRM(rm,reg);}voidtwoByteOp8(TwoByteOpcodeIDopcode,int32_toffset,RegisterIDbase,RegisterIDreg){m_buffer.ensureSpace(MaxInstructionSize);emitRexIf(byteRegRequiresRex(reg)|regRequiresRex(base),reg,0,base);m_buffer.putByteUnchecked(OP_2BYTE_ESCAPE);m_buffer.putByteUnchecked(opcode);memoryModRM(offset,base,reg);}voidtwoByteOp8(TwoByteOpcodeIDopcode,int32_toffset,RegisterIDbase,RegisterIDindex,intscale,RegisterIDreg){m_buffer.ensureSpace(MaxInstructionSize);emitRexIf(byteRegRequiresRex(reg)|regRequiresRex(base)|regRequiresRex(index),reg,index,base);m_buffer.putByteUnchecked(OP_2BYTE_ESCAPE);m_buffer.putByteUnchecked(opcode);memoryModRM(offset,base,index,scale,reg);}// Like twoByteOp8 but doesn't add a REX prefix if the destination reg// is in esp..edi. This may be used when the destination is not an 8-bit// register (as in a movzbl instruction), so it doesn't need a REX// prefix to disambiguate it from ah..bh.voidtwoByteOp8_movx(TwoByteOpcodeIDopcode,RegisterIDrm,RegisterIDreg){m_buffer.ensureSpace(MaxInstructionSize);emitRexIf(regRequiresRex(reg)|byteRegRequiresRex(rm),reg,0,rm);m_buffer.putByteUnchecked(OP_2BYTE_ESCAPE);m_buffer.putByteUnchecked(opcode);registerModRM(rm,reg);}voidtwoByteOp8(TwoByteOpcodeIDopcode,RegisterIDrm,GroupOpcodeIDgroupOp){m_buffer.ensureSpace(MaxInstructionSize);emitRexIf(byteRegRequiresRex(rm),0,0,rm);m_buffer.putByteUnchecked(OP_2BYTE_ESCAPE);m_buffer.putByteUnchecked(opcode);registerModRM(rm,groupOp);}// Immediates://// An immedaite should be appended where appropriate after an op has// been emitted. The writes are unchecked since the opcode formatters// above will have ensured space.// A signed 8-bit immediate.MOZ_ALWAYS_INLINEvoidimmediate8s(int32_timm){MOZ_ASSERT(CAN_SIGN_EXTEND_8_32(imm));m_buffer.putByteUnchecked(imm);}// An unsigned 8-bit immediate.MOZ_ALWAYS_INLINEvoidimmediate8u(uint32_timm){MOZ_ASSERT(CAN_ZERO_EXTEND_8_32(imm));m_buffer.putByteUnchecked(int32_t(imm));}// An 8-bit immediate with is either signed or unsigned, for use in// instructions which actually only operate on 8 bits.MOZ_ALWAYS_INLINEvoidimmediate8(int32_timm){m_buffer.putByteUnchecked(imm);}// A signed 16-bit immediate.MOZ_ALWAYS_INLINEvoidimmediate16s(int32_timm){MOZ_ASSERT(CAN_SIGN_EXTEND_16_32(imm));m_buffer.putShortUnchecked(imm);}// An unsigned 16-bit immediate.MOZ_ALWAYS_INLINEvoidimmediate16u(int32_timm){MOZ_ASSERT(CAN_ZERO_EXTEND_16_32(imm));m_buffer.putShortUnchecked(imm);}// A 16-bit immediate with is either signed or unsigned, for use in// instructions which actually only operate on 16 bits.MOZ_ALWAYS_INLINEvoidimmediate16(int32_timm){m_buffer.putShortUnchecked(imm);}MOZ_ALWAYS_INLINEvoidimmediate32(int32_timm){m_buffer.putIntUnchecked(imm);}MOZ_ALWAYS_INLINEvoidimmediate64(int64_timm){m_buffer.putInt64Unchecked(imm);}MOZ_ALWAYS_INLINEMOZ_MUST_USEJmpSrcimmediateRel32(){m_buffer.putIntUnchecked(0);returnJmpSrc(m_buffer.size());}// Data:voidjumpTablePointer(uintptr_tptr){m_buffer.ensureSpace(sizeof(uintptr_t));#ifdef JS_CODEGEN_X64m_buffer.putInt64Unchecked(ptr);#elsem_buffer.putIntUnchecked(ptr);#endif}voiddoubleConstant(doubled){m_buffer.ensureSpace(sizeof(double));m_buffer.putInt64Unchecked(mozilla::BitwiseCast<uint64_t>(d));}voidfloatConstant(floatf){m_buffer.ensureSpace(sizeof(float));m_buffer.putIntUnchecked(mozilla::BitwiseCast<uint32_t>(f));}voidsimd128Constant(constvoid*data){constuint8_t*bytes=reinterpret_cast<constuint8_t*>(data);m_buffer.ensureSpace(16);for(size_ti=0;i<16;++i)m_buffer.putByteUnchecked(bytes[i]);}voidint64Constant(int64_ti){m_buffer.ensureSpace(sizeof(int64_t));m_buffer.putInt64Unchecked(i);}voidint32Constant(int32_ti){m_buffer.ensureSpace(sizeof(int32_t));m_buffer.putIntUnchecked(i);}// Administrative methods:size_tsize()const{returnm_buffer.size();}constunsignedchar*buffer()const{returnm_buffer.buffer();}unsignedchar*data(){returnm_buffer.data();}booloom()const{returnm_buffer.oom();}boolisAligned(intalignment)const{returnm_buffer.isAligned(alignment);}voiddisableProtection(){m_buffer.disableProtection();}voidenableProtection(){m_buffer.enableProtection();}voidsetLowerBoundForProtection(size_tsize){m_buffer.setLowerBoundForProtection(size);}voidunprotectRegion(unsignedchar*first,size_tsize){m_buffer.unprotectRegion(first,size);}voidreprotectRegion(unsignedchar*first,size_tsize){m_buffer.reprotectRegion(first,size);}MOZ_MUST_USEboolappend(constunsignedchar*values,size_tsize){returnm_buffer.append(values,size);}private:// Internals; ModRm and REX formatters.// Byte operand register spl & above requir a REX prefix, which precludes// use of the h registers in the same instruction.staticboolbyteRegRequiresRex(RegisterIDreg){#ifdef JS_CODEGEN_X64returnreg>=rsp;#elsereturnfalse;#endif}// For non-byte sizes, registers r8 & above always require a REX prefix.staticboolregRequiresRex(RegisterIDreg){#ifdef JS_CODEGEN_X64returnreg>=r8;#elsereturnfalse;#endif}#ifdef JS_CODEGEN_X64// Format a REX prefix byte.voidemitRex(boolw,intr,intx,intb){m_buffer.putByteUnchecked(PRE_REX|((int)w<<3)|((r>>3)<<2)|((x>>3)<<1)|(b>>3));}// Used to plant a REX byte with REX.w set (for 64-bit operations).voidemitRexW(intr,intx,intb){emitRex(true,r,x,b);}// Used for operations with byte operands - use byteRegRequiresRex() to// check register operands, regRequiresRex() to check other registers// (i.e. address base & index).//// NB: WebKit's use of emitRexIf() is limited such that the// reqRequiresRex() checks are not needed. SpiderMonkey extends// oneByteOp8 and twoByteOp8 functionality such that r, x, and b// can all be used.voidemitRexIf(boolcondition,intr,intx,intb){if(condition||regRequiresRex(RegisterID(r))||regRequiresRex(RegisterID(x))||regRequiresRex(RegisterID(b))){emitRex(false,r,x,b);}}// Used for word sized operations, will plant a REX prefix if necessary// (if any register is r8 or above).voidemitRexIfNeeded(intr,intx,intb){emitRexIf(false,r,x,b);}#else// No REX prefix bytes on 32-bit x86.voidemitRexIf(boolcondition,int,int,int){MOZ_ASSERT(!condition,"32-bit x86 should never use a REX prefix");}voidemitRexIfNeeded(int,int,int){}#endifvoidputModRm(ModRmModemode,RegisterIDrm,intreg){m_buffer.putByteUnchecked((mode<<6)|((reg&7)<<3)|(rm&7));}voidputModRmSib(ModRmModemode,RegisterIDbase,RegisterIDindex,intscale,intreg){MOZ_ASSERT(mode!=ModRmRegister);putModRm(mode,hasSib,reg);m_buffer.putByteUnchecked((scale<<6)|((index&7)<<3)|(base&7));}voidregisterModRM(RegisterIDrm,intreg){putModRm(ModRmRegister,rm,reg);}voidmemoryModRM(int32_toffset,RegisterIDbase,intreg){// A base of esp or r12 would be interpreted as a sib, so force a// sib with no index & put the base in there.#ifdef JS_CODEGEN_X64if((base==hasSib)||(base==hasSib2))#elseif(base==hasSib)#endif{if(!offset)// No need to check if the base is noBase, since we know it is hasSib!putModRmSib(ModRmMemoryNoDisp,base,noIndex,0,reg);elseif(CAN_SIGN_EXTEND_8_32(offset)){putModRmSib(ModRmMemoryDisp8,base,noIndex,0,reg);m_buffer.putByteUnchecked(offset);}else{putModRmSib(ModRmMemoryDisp32,base,noIndex,0,reg);m_buffer.putIntUnchecked(offset);}}else{#ifdef JS_CODEGEN_X64if(!offset&&(base!=noBase)&&(base!=noBase2))#elseif(!offset&&(base!=noBase))#endifputModRm(ModRmMemoryNoDisp,base,reg);elseif(CAN_SIGN_EXTEND_8_32(offset)){putModRm(ModRmMemoryDisp8,base,reg);m_buffer.putByteUnchecked(offset);}else{putModRm(ModRmMemoryDisp32,base,reg);m_buffer.putIntUnchecked(offset);}}}voidmemoryModRM_disp32(int32_toffset,RegisterIDbase,intreg){// A base of esp or r12 would be interpreted as a sib, so force a// sib with no index & put the base in there.#ifdef JS_CODEGEN_X64if((base==hasSib)||(base==hasSib2))#elseif(base==hasSib)#endif{putModRmSib(ModRmMemoryDisp32,base,noIndex,0,reg);m_buffer.putIntUnchecked(offset);}else{putModRm(ModRmMemoryDisp32,base,reg);m_buffer.putIntUnchecked(offset);}}voidmemoryModRM(int32_toffset,RegisterIDbase,RegisterIDindex,intscale,intreg){MOZ_ASSERT(index!=noIndex);#ifdef JS_CODEGEN_X64if(!offset&&(base!=noBase)&&(base!=noBase2))#elseif(!offset&&(base!=noBase))#endifputModRmSib(ModRmMemoryNoDisp,base,index,scale,reg);elseif(CAN_SIGN_EXTEND_8_32(offset)){putModRmSib(ModRmMemoryDisp8,base,index,scale,reg);m_buffer.putByteUnchecked(offset);}else{putModRmSib(ModRmMemoryDisp32,base,index,scale,reg);m_buffer.putIntUnchecked(offset);}}voidmemoryModRM_disp32(int32_toffset,RegisterIDindex,intscale,intreg){MOZ_ASSERT(index!=noIndex);// NB: the base-less memoryModRM overloads generate different code// then the base-full memoryModRM overloads in the base == noBase// case. The base-less overloads assume that the desired effective// address is://// reg := [scaled index] + disp32//// which means the mod needs to be ModRmMemoryNoDisp. The base-full// overloads pass ModRmMemoryDisp32 in all cases and thus, when// base == noBase (== ebp), the effective address is://// reg := [scaled index] + disp32 + [ebp]//// See Intel developer manual, Vol 2, 2.1.5, Table 2-3.putModRmSib(ModRmMemoryNoDisp,noBase,index,scale,reg);m_buffer.putIntUnchecked(offset);}voidmemoryModRM_disp32(constvoid*address,intreg){int32_tdisp=AddressImmediate(address);#ifdef JS_CODEGEN_X64// On x64-64, non-RIP-relative absolute mode requires a SIB.putModRmSib(ModRmMemoryNoDisp,noBase,noIndex,0,reg);#else// noBase + ModRmMemoryNoDisp means noBase + ModRmMemoryDisp32!putModRm(ModRmMemoryNoDisp,noBase,reg);#endifm_buffer.putIntUnchecked(disp);}voidmemoryModRM(constvoid*address,intreg){memoryModRM_disp32(address,reg);}voidthreeOpVex(VexOperandTypep,intr,intx,intb,intm,intw,intv,intl,intopcode){m_buffer.ensureSpace(MaxInstructionSize);if(v==invalid_xmm)v=XMMRegisterID(0);if(x==0&&b==0&&m==1&&w==0){// Two byte VEX.m_buffer.putByteUnchecked(PRE_VEX_C5);m_buffer.putByteUnchecked(((r<<7)|(v<<3)|(l<<2)|p)^0xf8);}else{// Three byte VEX.m_buffer.putByteUnchecked(PRE_VEX_C4);m_buffer.putByteUnchecked(((r<<7)|(x<<6)|(b<<5)|m)^0xe0);m_buffer.putByteUnchecked(((w<<7)|(v<<3)|(l<<2)|p)^0x78);}m_buffer.putByteUnchecked(opcode);}AssemblerBufferm_buffer;}m_formatter;booluseVEX_;};}// namespace X86Encoding}// namespace jit}// namespace js#endif /* jit_x86_shared_BaseAssembler_x86_shared_h */